Ts recarga el código fuente
Este problema tiene tres niveles. Veámoslo uno por uno.
Los requisitos para el primer nivel son los siguientes:
Implementar una función zip para fusionar los elementos de dos matrices en orden, por ejemplo, al ingresar, devuelve,,]
Esta capa toma un elemento de dos matrices a la vez, lo fusiona y lo coloca en la matriz, y luego continúa procesando el siguiente, realizando este proceso de forma recursiva hasta que la matriz esté vacía.
¿Función zip(? destino, fuente)? {
¿Si (!target.length ||!source.length)? return[];
const[uno,...descanso 1]= destino;
const[otro,...descanso 2]= fuente;
Return [[uno, otro],...zip(rest1,rest 2)];}
El resultado es correcto.
También hay dos tipos: tipo de función de declaración de función directa y tipo de función de declaración de interfaz y luego se agrega al tipo de variable.
Debido a que se desconoce el tipo de elemento específico, utilizamos desconocido.
Aquí puedes preguntar la diferencia entre cualquiera y desconocido:
Cualquiera y desconocido puede recibir cualquier tipo:
Pero cualquiera puede asignarse a cualquier tipo, desconocido no puedo.
Esto sólo se utiliza para recibir otros tipos, por lo que desconocido es más apropiado y seguro que cualquier otra cosa.
Este nivel también es de sintaxis ts relativamente básica, y el tercer nivel es más difícil:
Utilice la programación de tipos para lograr indicaciones de tipo precisas, como cuando se pasan parámetros y el se debe solicitar el tipo del valor de retorno. ,,]
Aquí se requiere que el tipo de valor de retorno sea preciso, por lo que debemos generar dinámicamente el tipo de valor de retorno según el tipo del parámetro.
Eso es todo:
Declare dos parámetros de tipo, Destino y Origen, restringidos a desconocido[], que es un tipo de matriz de cualquier tipo de elemento.
Estos dos tipos de parámetros son los tipos de los dos parámetros pasados.
El valor de retorno lo calcula Zip.
Luego necesitamos implementar el tipo avanzado de Zip:
Los parámetros de tipo entrante son dos tipos de matriz, y también necesitamos extraer cada elemento de ellos y fusionarlos.
Los elementos se pueden extraer mediante coincidencia de patrones:
Así que este tipo se puede definir de la siguiente manera:
typeZip lt a? extendsunknown[], ¿otros? extendsunknown[]>=
¿Uno? Extender[Primero inferir uno,...inferir Rest1]
¿Otros? Extender [Inferir otros] primero,...Inferir los 2 restantes]
[[OneFirst, OtherFirst],...Zip ltRest1, Rest2 gt]
: []
: [];
Extraiga los primeros elementos de las dos matrices respectivamente y construya una nueva matriz. Luego haga esto de forma recursiva para el resto de la matriz hasta que la matriz esté vacía.
Esto implementa el tipo de alto nivel que queremos:
Pero si lo agrega como valor de retorno a una función, obtendrá un error:
Como no sabes cuáles son los parámetros al declarar una función, naturalmente no puedes calcular ZIP
Entonces, ¿qué debemos hacer?
Se puede resolver mediante la sobrecarga de funciones:
Ts admite la sobrecarga de funciones. Puede escribir las definiciones de tipo de múltiples funciones con el mismo nombre y, finalmente, escribir la implementación de la función. de modo que cuando se use Al llamar a esta función, el tipo de función coincidirá según el tipo de parámetro.
Las funciones que utilizamos programación de tipos no reportarán errores si están escritas de esta manera.
El código completo es así:
typeZip lt one? extendsunknown[], ¿otros? extendsunknown[]>=uno? Expandir[
Inferir uno primero,
...Inferir el 1 restante
]
¿Otros? Extender [Inferir otros] primero,...Inferir los 2 restantes]
[[OneFirst, OtherFirst],...Zip ltRest1, Rest2 gt]
: []
：[];
typeMutable ltObj gt= {
-solo lectura [¿Clave? inkeyof Obj]:Obj[Clave];
};
Función zip(? destino: desconocido[], fuente: desconocido[]):? desconocido[]? ;
Función lt? Targetextendsreadonlyunknown[],? sourceextendsreadonlyunknown[] gt (
destino: destino,
fuente: fuente
): ?Zip lt? ¿Lt variable? ¿Objetivo gt? ¿Variable lt? Fuente gt gt;
Función zip(? destino: desconocido[], fuente: desconocido[])? {
¿Si (!target.length ||!source.length)? return[];
const[uno,...descanso 1]= destino;
const[otro,...descanso 2]= fuente;
Return [[uno, otro],...zip(rest1,rest 2)];
}
constresult = zip([?1,?2,?3 ] ?asconst,[?4,?5,?6]?asconst);
constarr1 = [? 1,?2,?3];
constarr2 = [? 4,?'5',?6];
constresult2 = zip(arr1, arr 2);
Resumen
Hoy hicimos una entrevista ts completa Las preguntas tienen tres niveles:
El primer nivel implementa la lógica de js, que se puede lograr mediante recursividad o bucle.
La segunda capa agrega un tipo a la función, usa la función para declarar el tipo y usa la interfaz para declarar el tipo de función. Tanto los parámetros como el valor de retorno son desconocidos[].
El tercer nivel consiste en utilizar la programación de tipos para lograr sugerencias de tipos precisas. Esta capa necesita obtener los tipos de parámetros y devolverlos extrayendo los tipos de elementos y construyendo un nuevo tipo de matriz. Los tipos también deben declararse mediante la sobrecarga de funciones, prestando atención al orden en que se declaran los tipos sobrecargados.
Debido a que const puede hacer que un literal derive de un tipo literal, pero estará decorado con solo lectura, puedes escribir tu propio tipo mapeado para eliminar esta decoración.
De hecho, este es también el orden en el que aprendemos ts. Primero debemos poder escribir lógica js, luego saber cómo agregar tipos ts a funciones y clases, y luego aprender programación de tipos y saber cómo generar tipos dinámicamente.
Entre ellos, la programación de tipos es la parte más difícil de ts y la más poderosa. Después de conquistar este nivel, se puede decir que lo entiende.