ANGULAR en menos de 128 palabras – TypeScript – Parte 3

TypeScript es un lenguaje con tipo muy tipado, orientado a objetos y compilado. TypeScript es un desensamblado típico de JavaScript compilado en JavaScript. TypeScript es JavaScript y algunas características adicionales.

La documentación de la tipola está disponible en este enlace: https://www.typescriptlang.org/docs/home.html

Instalación de TypeScript:

sudo npm install -g typescript

Ejecución del compilador TypeScript:

tsc --version

Creación de un primer ejemplo de TypeScript:

Creación del archivo test.ts:

función saludo (nombre)
    console.log ("Hola, " - nombre);
}

nombre de usuario var - "John";
saludo (nombre de usuario);

Compilación del código:

tsc test.ts

Al final del pedido se crea un archivo test.js que se puede ver:

función saludo (nombre)
    console.log ("Hola, " - nombre);
}
nombre de usuario var - "John";
saludo (nombre de usuario);

Encontramos que para este ejemplo el código es el mismo en javascript y typescript, podemos ejecutar:

Node test.js
Buenos días, John.

Definición de una variable con TypeScript:

Es posible declarar una variable con var que es clásica en javascript o con let que es más segura con TypeScript. Declarar una variable con var le da un ámbito global, es decir, la variable está disponible en todo el código, el ámbito de la variable se limita al "bloque más cercano"

Ejemplo 1: uso de var (ámbito global)

pantalla de función (prueba)
    var cuenta 1;

    si (prueba)
        aumento var - recuento -5;
        aumento del retorno;
    }

    aumento del retorno;
}


pantalla (false);

Este código compila pero conlleva riesgos porque la variable de aumento no se ha declarado si la configuración de prueba es false.

Ejemplo 2: uso de menos (ámbito limitado al bloque más cercano)

Para el siguiente código, la compilación se equivoca debido a la limitación del ámbito del aumento de la variable.

pantalla de función (prueba)
    Deje que cuente 1;

    si (prueba)
        Aumentar - recuento - 5;
        aumento del retorno;
    }

    Error de la variable no existe
    aumento del retorno;
}
pantalla (true);

test.tsc.ts
test.ts:10:12 - error TS2304: Puede encontrar el nombre 'increase'.

Tipo de escritura:

Vamos a contar 10
Cuenta 'hola'

La compilación del código anterior confirma la escritura segura del idioma, al compilar el siguiente error se elimina:

test.tsc.ts
test.ts:2:1 - error TS2322: El tipo '"hola" no se puede asignar al tipo 'número'.

Anotación de tipo TypeScript:

Los siguientes tipos se pueden anotar en TypeScript:

dejar un: número; entero y decimal
let b: booleano;
dejar c: tanga;
vamos a: cualquiera;
seamos: número[];
let f: núme[]ro [4, 5, 6]'
vamos g: cualq[]uier . .[4, 'Hello', true, 6] .
const letterA - 'A';
Const color verde - 1;

Lista en TypeScript:

enum Dirección
    Alto -1,
    en Bas - 2,
    aIzquierda - 3,
    aRight - 4
}

siguiente Dirección - Direction.enHaut;

Si nos fijamos en el código anterior después de la compilación por tsc observamos que el código TypeScript es mucho más cómodo que el de JavaScript:

Dirección Var;
(función (Dirección)
    Direcció[Direction["enHaut"]n - 1] - "alto";
    Dirección[Direction["enBas"] - 2] - "Abajo";
    Dirección[Direction["aGauche"] - 3] - "Izquierda";
    Dirección[Direction["aDroite"] - 4] - "derecha";
(Dirección) (Dirección));
vardirection - Direction.enHaut;

ANGULAR en menos de 128 palabras – Parte 2

Este artículo sigue la primera parte: http://128mots.com/index.php/2020/02/27/angular-en-plus-de-128-mots-partie-1/

Estructura de un proyecto Angular:

  • e2e: Pruebas automatizadas de extremo a extremo
  • node_modules: módulos de terceros instalados para el proyecto de desarrollo (a través del comando npm install)
  • src: archivo de aplicación principal
  • app: Módulos y componentes de la aplicación
  • assests: almacenamiento de elementos estáticos (imágenes, script …)
  • entornos: Contiene variables ambientales
  • favicon.ico: Icono de la aplicación
  • index.html: el archivo html principal de la aplicación
  • hand.ts: punto de entrada de la aplicación (inicia AppModule)
  • polyfills.ts: Adapta javascript al navegador
  • style.css: hoja de estilos
  • tsconfig.ts: configuración de typescript
  • karma.conf.js: configuración del entorno de prueba

ANGULAR en más de 128 palabras – Parte 1

Angular es un marco para crear aplicaciones cliente, basado en HTML/CSS y JavaScript/TypeScript.

Angular ofrece las siguientes ventajas:

  • Módulo de patrón revelador: organiza el código en uno o más módulos y proporciona una mejor estructura.
  • Arquitectura limpia y estructurada.
  • Código reutilizable.
  • Aplicación más fácil de probar.

Arquitectura:

  • Front-End: se encarga de la lógica de presentación. Compuesto de HTML / CSS / TypeScript / Angular
  • Backend: se encarga de la lógica empresarial. Compuesto de datos – API

Crear una primera aplicación Angular:

NodeJS: El entorno de ejecución de Node.js incluye todo lo que necesita para ejecutar un programa escrito en JavaScript. Para instalar el vínculo https://node.js.org

Administrador de paquetes de nodos: Esta es una utilidad de control en línea que facilita la instalación de paquetes, gestión de versiones y gestión de dependencias.

Angular-Cli: una interfaz de línea de comandos para automatizar el flujo de trabajo de desarrollo. Le permite:

  • Crea una nueva aplicación Angular.
  • Ejecute un servidor de desarrollo con compatibilidad con "Live Reload" para obtener una vista previa de la aplicación durante el desarrollo.
  • Añade características a tu aplicación Angular.
  • Ejecutar pruebas unitarias
  • Ejecutar pruebas de extremo a extremo
  • Compile la aplicación para su implementación en producción
  • Implementar la aplicación en un servidor

Instalación de pedidos en línea Angular-cli:

npm install -g @angular-cli

Esta notación con 'NPM' permite que los paquetes nPM se espacien fuera de los nombres. Cada usuario y organización en NPM tiene su propio alcance y son los únicos que pueden agregar paquetes.

Esto es útil por varias razones:

  • Permite a las organizaciones indicar claramente qué paquetes son "oficiales" y cuáles no. Por ejemplo, el ámbito @angular, garantiza que fue publicado por el equipo principal de Angular.
  • El nombre del paquete debe ser único dentro de su ámbito de publicación, pero no para todo el registro npm.
    Por ejemplo, el nombre del paquete http ya está tomado en el repositorio principal npm, pero Angular también puede tener angular/http.

Para más detalles, la documentación se puede encontrar en este enlace: https://docs.npmjs.com/

Cree un paquete Angular:

ng nuevo paquete-prueba-angular

Edite el código del proyecto Angular creado:

Te aconsejo que edites el código con el editor vsCode: https://code.visualstudio.com/ o con el editor de código Sublime Text https://www.sublimetext.com/

Si utiliza vscode, el siguiente comando se puede utilizar en la raíz del proyecto.

Código.

Implemente el proyecto angular en el servidor de máquina local:

ng servir

A continuación, se puede buscar en localhost:4200.

El algoritmo de la k vecina más cercana (KNN) en Python en menos de 128 palabras.

El algoritmo k-learning más cercano (KNN) se utiliza para realizar la clasificación de datos.

Para predecir la clasificación de un nuevo dato, el algoritmo se basa en los registros k del conjunto de datos de aprendizaje se encuentran más similares a este nuevo registro.

La similitud entre los registros se puede medir de diferentes maneras. Generalmente un buen punto de partida es la distancia Euclides.

El algoritmo es el siguiente:

Para una entrada x ¿cuál es su clase y si confío en el neighborkk establecido más cercano a x?

  1. Encontrar la parte k introducir los datos de entrenamiento que son los más cercanos a mi entrada x (aquí vamos a utilizar por ejemplo la distancia Euclides)
  2. Haga que cada uno de estos datos de entrenamiento vote por su clase.
  3. Devolver la clase mayoritaria

El éxito del algoritmo dependerá de la cantidad de datos de entrenamiento y de la calidad de la medición de la distancia entre 2 vectores x.

Este es un ejemplo de Uso e implementación de Python en la base de datos que se relaciona con la concesión de un crédito basado en la edad y la cantidad solicitada. La clase es la respuesta Sí o NO.

de matemáticas importación sqrt
 
Hacer una predicción de clasificación
def predire_classification (donnee_test, formación, nombre_voisins_vote):
	vecinos - recherche_voisins (formación, donnee_test, nombre_voisins_vote)
	salida -[vecteur[-1] para vector en vecinos]
	predicción - max (set), key-exit.count)
	predicción de retorno


 euclidiana #Distance de 2 vectores
def distance_euclidienne (vector1, vector2):
	distancia - 0,0
	para i en el rango (len)-1):
		distancia (vecto[i]r1 - vect[i]or2)
	retorno sqrt (distancia)
 

Búsqueda de vecinos
def recherche_voisins (entrenamiento, donnee_test, nbVoisins):
	distancias - list()
	para la formación en línea en formación:
		dist - distance_euclidienne (donnee_test, Línea de entrenamiento)
		distances.append (línea de entrenamiento, dist)
	distances.sort (key-lambda tup: tu[1]p)
	kVoisins - list()
	para i en el rango (nbVoisins):
		kVoisins.append (distancia[i][0]s)
	devolver kVoisins
 
 
Datos de formación
El aprendizaje da[[25,40000,'NON'],
		   [30,60000,'OUI'],
		   ,
		   ,
		   ,
		   ,
		   ,
		   ,
		   ,
		   [32,10000,'NON']]

predicción - predire_classification (aprendizaje, d[1]onación, aprendizaje, 3)
imprimir ('Debemos encontrar %s, la predicción es: %s.' % (dadoSLearning[1][-1], predicción))

Implementación de Python del algoritmo de Dijkstra

Este artículo sigue el siguiente artículo sobre el algoritmo de Dijkstra: http://128mots.com/index.php/2020/02/17/lalgorithme-de-dijkstra-dans-un-graphe-pondere-et-oriente-en-plus-de-128-mots/

Aquí está la implementación de Python del algoritmo

de colecciones importar deque

def dijkstra (gráfico, vértice):
    cola - deque([vertex])
    distancia ' vértice: 0'
    mientras que la cola:
        t - tail.popleft()
        impresión ("Estamos visitando la cumbre" - str(t))
        para vecino en gráfic[t]o:
                tail.append (vecino)
                nouvelle_distance - distancia [t]- gráfico[t][voisin]
                si (vecino no a distancia o nouvelle_distance< distance):></ distance[voisin]):>
                    distanci[voisin]a a nouvelle_distance
                    imprimir ("Actualizar la cumbre" - str (vecino) - " con distancia: " - str(nouvelle_distance))
                    
    distancia de retorno



gráfico ajacence #Liste
gráfico ''A':'B':15,'C':4','B':'E':5','C':':'E':11,'D':2','D':'E':3','E':
distancia - dijkstra (gráfico, 'A')
impresión ("Distancias" - str (distancia))

Algoritmo de Dijkstra en un gráfico ponderado y orientado en más de 128 palabras

Para un pico de origen dado en el gráfico, el algoritmo busca la ruta más corta entre ese nodo y todos los demás.

Aquí se utiliza un gráfico ponderado, que es un gráfico en el que cada arco (caso de un gráfico orientado) recibe un peso. Por lo tanto, un gráfico ponderado es un tipo especial de gráfico etiquetado en el que las etiquetas son números.

El peso de una cadena o trayectoria es la suma de los pesos de los arcos que componen la cadena.

El algoritmo entra en un gráfico ponderado y una cumbre a partir de la cual calcula las distancias, los pasos son:

Fase de inicialización:

  • En todas las partes superiores, una etiqueta igual al infinito (o en la longitud máxima posible – 1) se coloca en todas las partes superiores.
  • La etiqueta se inicia en A a 0

Fase de tratamiento:

  • Tratamos una cumbre (aquí comenzamos con A)
  • Marcamos la cumbre como visitada
  • Liberamos los arcos salientes de la cumbre, es decir, tratamos de actualizar el valor de la etiqueta de la parte superior del acabado por distancia.
  • Si el valor de la carretera hasta la parte superior del acabado es inferior al calculado, la etiqueta superior se actualiza con esta distancia total.
  • La siguiente parte superior a tratar es la que tiene el peso más bajo.

Ejemplo:

Puesta en marcha del algoritmo
El arco saliente A-B se libera, la distancia es 15, 15 siendo un mejor valor que el infinito actualizamos la etiqueta B con 15
El arco saliente A-C se libera la distancia 4 siendo mejor que el infinito actualizamos la etiqueta de la parte superior C
La siguiente parte superior del algoritmo es la que aún no se ha visitado y tiene la etiqueta con el valor más bajo. Aquí es la parte superior c con el valor 4.On
libera el arco de salida C-E, la distancia calculada desde la parte superior A es 4 – 11 – 15. 15 siendo mejor que el infinito actualizamos la etiqueta de la parte superior E.
Se libera el Arco C-D saliente, la distancia calculada desde la parte superior A es 4 – 2 – 6. 6 siendo mejor que el infinito actualizamos la etiqueta de la parte superior D.

En el siguiente paso visitamos la cumbre D porque su valor es el más bajo del gráfico
On libera el arco saliente D-E y calcula la distancia desde la parte superior A que es igual a 9 o una distancia inferior a 15 (calculado en la etapa anterior)A con
tinuación, anulamos la selección del arco C-E que anteriormente se calculó como la mejor ruta para ir de la A a la E y se actualiza la cumbre E con el valor
9.La cumbre E se sigue tratada, no hay arco saliente por lo que no hay ninguna actualización.
El B-top se procesa: el arco B-E saliente se libera, la distancia de 15 -5 -20 es mayor que el valor de 9 de la cumbre E no hay actualización y el algoritmo termina.

Implementación de Python de la ruta de acceso de ancho en gráficos (BFS)

Este artículo sigue el del algoritmo BFS aquí: http://128mots.com/index.php/2020/02/11/parcours-en-largeur-dans-les-graphes-bfs/

La implementación de Python de este algoritmo es la siguiente:

de colecciones importar deque

def bfs (gráfico, vértice):
    cola - deque([vertex])
    distancia ' vértice: 0'
    padre ' vértice: Ninguno'
    mientras que la cola:
    	t - tail.popleft()
    	para vecino en gráfic[t]o:
    		Si el vecino no está a distancia:
    			tail.append (vecino)
    			distanci[voisin]a - distanci[t]a - 1
    			padr[voisin]e 't'
    distancia de retorno, padre


gráfico ajacence #Liste
Gráfico
	'A': ['B','C'],
	'B': ['A','C', 'D'],
	'C': ['D'],
	'D':['C','A']
}

distancia, pere - bfs (gráfico, 'A')
impresión ("Distancias" - str (distancia))
impresión ("Pere" - str (padre))

Curso amplio en The Graphs (BFS)

La ruta de ancho del gráfico (BFS) es un algoritmo que se utiliza para examinar las estructuras de datos del gráfico. BFS implementa una estrategia específica para visitar todas las cimas de un gráfico

BFS comienza con una cumbre, luego comprueba a los vecinos de la cumbre inicial, luego a los vecinos de los vecinos, etc.

En la entrada del algoritmo está el gráfico G y un punto de partida D para el que la distancia se considera 0.

Fuera del algoritmo se calculan todas las distancias entre la parte superior D y cada parte superior del gráfico G, así como el árbol que cubre si el gráfico G está relacionado (es decir, para cualquier par de topthere hay un camino entre ellos en el gráfico).

Se utilizan las siguientes tablas:

  • Distancia[.]: Almacena la distancia entre D (parte superior inicial) y otra parte superior del gráfico.
  • Padre: A[.]lmacena el padre en la parte superior de una parte superior del gráfico recorrido.
  • Visita[.]: Almacena el estado de la visita de la cumbre, posible lista de valores 0:todavía no visitados,1:Visita en curso,2:Visitado

Para un carril F se utilizan las siguientes funciones:

  • Primero (F): Devuelve el elemento a la parte superior del carril F sin quitarlo.
  • Dequeue(F): Devuelve el elemento a la parte superior de la línea F quitándolo.
  • Anexar (F, A): Coloque el elemento A en el carril F en la parte posterior de la línea.

Los pasos son:

  • Fase de inicialización
    • 1. Por todas las cumbres
      • Visita – 0 (Aún no visitado)
      • Pere – null (Inicializa la tabla)
      • Distancia – -1
    • 2. Anexar (F,D) (añade el elemento inicial)
    • 3. Distanc[R]ia – 0 (premisa de inicio)
  • Fase de acción (ruta del gráfico G)
    • Mientras la línea F no esté vacía
      • t – Primero (F)
      • Para todos los vecinos v t hacer
        • Si la visi[v]ta 0 (la cumbre no visitada) entonces
          • Visita[v] – 1 (Visita en curso)
          • Distanci[v]a – Distanci[t]a – 1
          • Padre[v] – t
          • Anexar (F,v)
      • Dequeue (F)
      • Visi[t]ta 2

Si detallamos los pasos con el caso del gráfico de ejemplo a continuación.

Fase de inicialización:

Inicializando el elemento A es el elemento inicial remoto 0, se colorea de color naranja para indicar que la visita está en curso.

Visita de los vecinos de la Cumbre A (Visita de la Cumbre B)

La Cumbre B pasa durante la visita, se calcula su distancia de A y se añade la cumbre A como cumbre paterna. Se añade a la línea.

Visita de los vecinos de la Cumbre A (Visita cumbre C)

La Cumbre C pasa durante la visita, su distancia de A se calcula y la cumbre A se añade como la cumbre padre. Se añade a la línea.

Marcar A como visitado y eliminar la cola

A se marca como visitado (color azul) y se elimina de la cabeza de la cola

Visita de los vecinos de la Cumbre B (Visita de la Cumbre D)

La cumbre C está marcada ya que durante la visita no se visitará, se visita la cumbre D se calcula su distancia 2 y se observa la cumbre B como padre de la cumbre B.

Marcar B y C como visitados y eliminar la cola

B se marca como visitado (color azul) y se quita de la cabeza de la lín
eaC se marca como visitado (color azul) y se quita de la cabeza de la cola (su vecino D se marca durante la visita)

Marcar D como visitado y final del algoritmo

D se marca como visitado (color azul) y se elimina de la cabeza de la cola.
Fin del algoritmo

Construir el árbol que cubre si el gráfico está relacionado

Si el gráfico está relacionado, el resultado de la ruta se despliega y el árbol se cubre con el gráfico que contiene todos los picos.

Aplicación: La ruta de anchura de un gráfico (BFS) es útil para:

  • Compruebe si un gráfico está relacionado (todas las tapas se marcan como visitadas al final del algoritmo).
  • Calcular distancias desde un pico determinado
  • Construir un árbol que cubra un gráfico