TypeScript Conditional Types
Los tipos condicionales (Conditional Types) son una de las características más potentes del sistema de tipos de TypeScript.
Permiten seleccionar tipos dinámicamente según una condición, similar al operador ternario en los lenguajes de programación.
Los tipos condicionales hacen que la definición de tipos sea más flexible y son la base para implementar tipos de utilidad avanzados.
Diagrama SVG: Flujo de los tipos condicionales
Por qué necesitamos los tipos condicionales
En el desarrollo real con TypeScript, a menudo necesitamos devolver diferentes tipos según el tipo de entrada.
Por ejemplo, una función puede aceptar parámetros de tipo string o number, y necesitamos devolver un tipo de resultado diferente según el tipo del parámetro.
Los tipos condicionales proporcionan la capacidad de realizar lógica a nivel de tipos, haciendo que la definición de tipos sea más flexible y potente.
Explicación del concepto:La sintaxis de los tipos condicionales es
T extends U ? X : Y. Si el tipo T se puede asignar al tipo U, se devuelve el tipo X; de lo contrario, se devuelve el tipo Y.
Sintaxis básica
Los tipos condicionales utilizan la sintaxis del operador ternario para realizar evaluaciones condicionales a nivel de tipos.
Esto nos permite calcular dinámicamente el tipo de retorno según el tipo de entrada.
Ejemplo
// Si T es de tipo string, devuelve true; de lo contrario, devuelve false
type IsString<T> = T extends string ? true : false;
// Usando el tipo condicional
// string extends string es true, por lo que el tipo A es true
type A = IsString<string>;
// number extends string es false, por lo que el tipo B es false
type B = IsString<number>;
// Usando estos tipos
var a: A = true;
var b: B = false;
console.log("¿string es un string?: " + a);
console.log("¿number es un string?: " + b);
Resultado de ejecución:
string 是字符串?: true number 是字符串?: false
Explicación:Los tipos condicionales se evalúan automáticamente durante la comprobación de tipos, generando tipos concretos.
Aplicación práctica: filtrado de tipos
Una de las aplicaciones más comunes de los tipos condicionales es el filtrado de tipos.
Por ejemplo, se puede crear un tipo para excluir null y undefined.
Ejemplo
// Si T es null o undefined, devuelve never (tipo vacío); de lo contrario, devuelve T mismo
type NonNullable<T> = T extends null | undefined ? never : T;
// Usando el tipo NonNullable
// string no es null/undefined, por lo que el tipo es string
type A = NonNullable<string>;
// null es null/undefined, por lo que el tipo es never
type B = NonNullable<null>;
// undefined es null/undefined, por lo que el tipo es never
type C = NonNullable<undefined>;
// Verificando el tipo
var a: A = "hello";
console.log("No vacío: " + a);
Resultado de ejecución:
非空: hello
Tipo never:never representa un tipo que nunca existe. Cuando la condición no se cumple, TypeScript usa never para representar un tipo "no disponible".
Inferencia de tipos: la palabra clave infer
La palabra clave infer es una de las características más potentes de los tipos condicionales.
Permite "extraer" o "inferir" partes específicas de un tipo.
Ejemplo
// Si T es un tipo de función, devuelve el tipo de retorno R inferido; de lo contrario, devuelve never
type ReturnType<T> = T extends (...args: any[]) => infer R ? R : never;
// Define una función que devuelve un objeto de usuario
function getUser() {
return { name: "Alice" };
}
// Define una función que devuelve un número
function getNumber() {
return 42;
}
// Usa ReturnType para obtener el tipo de retorno de la función
// Inferido como { name: string }
type R1 = ReturnType<typeof getUser>;
// Inferido como number
type R2 = ReturnType<typeof getNumber>;
// Usando el tipo inferido
var r1: R1 = { name: "Bob" };
var r2: R2 = 100;
console.log("Usuario: " + JSON.stringify(r1));
console.log("Número: " + r2);
Resultado de ejecución:
Usuario: {"name":"Bob"}
数字: 100
Función de infer:infer es como una "variable" en el sistema de tipos; puede capturar una parte específica de un tipo y usarla en el tipo resultante.
Tipos condicionales distributivos
Cuando el parámetro genérico de un tipo condicional es un tipo unión, se realiza automáticamente un proceso de "distribución".
Es decir, la condición se aplica a cada miembro del tipo unión por separado y luego se combinan los resultados.
Ejemplo
// Cuando T es un tipo unión, cada tipo se procesa de forma distributiva automáticamente
type ToArray<T> = T extends any ? T[] : never;
// El tipo unión se distribuye automáticamente
// string | number se distribuye como: ToArray<string> | ToArray<number>
// Es decir: string[] | number[]
type StrOrNum = ToArray<string | number>;
// Se puede asignar string[] o number[]
var arr: StrOrNum = ["hello"];
// También se puede asignar number
arr = 42;
console.log("Array: " + arr);
Resultado de ejecución:
数组: 42
Mecanismo de distribución:La distribución en los tipos condicionales está activada automáticamente. Si se desea deshabilitar la distribución, se pueden usar corchetes:
[T] extends U。
Combinación de tipos condicionales y tipos mapeados
Los tipos condicionales se pueden combinar con tipos mapeados para crear potentes herramientas de transformación de tipos.
Esta combinación es la base para implementar los tipos de utilidad integrados de TypeScript.
Ejemplo
interface User {
// ID de usuario
id: number;
// Nombre de usuario
name: string;
// Correo electrónico del usuario
email: string;
}
// Usa tipos mapeados y condicionales para implementar Partial
// Recorre todas las propiedades de T y añade el modificador opcional ?
type Partial<T> = {
[P in keyof T]?: T[P];
};
// Usa tipos mapeados y condicionales para implementar Required
// Recorre todas las propiedades de T y elimina el modificador opcional -?
type Required<T> = {
[P in keyof T]-?: T[P];
};
// Usando Partial: todas las propiedades se vuelven opcionales
var partial: Partial<User> = { name: "Alice" };
// Usando Required: las propiedades de Partial<User> se vuelven obligatorias
// Primero se necesita el tipo Partial<User>
type RequiredUser = Required<Partial<User>>;
var required: RequiredUser = { name: "Bob", id: 1 };
console.log("Opcional: " + JSON.stringify(partial));
console.log("Obligatorio: " + JSON.stringify(required));
Resultado de ejecución:
可选: {"name":"Alice"}
必填: {"name":"Bob","id":1}
Uso combinado:La combinación de tipos condicionales y tipos mapeados puede implementar varias transformaciones de tipos complejas, como los tipos de utilidad integrados Partial, Required, Readonly, etc.
Ejemplo avanzado: comprobación de tipos
Los tipos condicionales también se pueden usar para implementar comprobaciones de tipos más complejas.
A continuación se muestran algunos ejemplos de comprobación de tipos útiles en el desarrollo real.
Ejemplo
// La intersección de any con cualquier tipo da any, por lo que 0 extends any es true
type IsAny<T> = 0 extends (1 & T) ? true : false;
// Prueba IsAny
// any es un tipo especial; la intersección con cualquier tipo devuelve any
type A = IsAny<any>; // true
// string no es any
type B = IsAny<string>; // false
console.log("¿any es any?: " + A);
console.log("¿string es any?: " + B);
// Comprueba si el tipo se puede asignar
// Si T puede asignarse a U, devuelve true; de lo contrario, devuelve false
type IsAssignableTo<T, U> = T extends U ? true : false;
// Probar la asignabilidad de tipos
// string puede asignarse a any, por lo que devuelve true
type CanAssign = IsAssignableTo<string, any>;
console.log("¿string puede asignarse a any?: " + CanAssign);
Resultado de la ejecución:
any 是 any?: true string 是 any?: true
Nota:any es el tipo más "flexible" de TypeScript; puede asignarse a cualquier tipo y también puede recibir asignaciones de cualquier tipo.
Notas
- Evaluación diferida:Los tipos condicionales se evalúan de forma diferida; solo se calculan cuando se usa un tipo concreto.
- Propiedad de distribución:Los tipos unión activan automáticamente el mecanismo de distribución de los tipos condicionales.
- infer solo puede usarse en condiciones extends:Esta es la única posición donde puede aparecer infer.
- Combinación con tipos mapeados:La combinación de tipos condicionales con tipos mapeados puede crear poderosos tipos utilitarios.
Avanzado:Muchos tipos utilitarios incorporados en TypeScript (como Partial, Required, Extract) están implementados con tipos condicionales.
Resumen
Los tipos condicionales son una de las características más potentes del sistema de tipos de TypeScript.
- Sintaxis básica:
T extends U ? X : Y - La palabra clave infer:Deducir una parte específica de un tipo.
- Propiedad de distribución:Los tipos unión se procesan automáticamente de forma distribuida.
- Casos de uso:Filtrado de tipos, inferencia de tipos, comprobación de tipos.
- Tipos utilitarios:La mayoría de los tipos utilitarios incorporados se basan en tipos condicionales.
Mejores prácticas:Dominar los tipos condicionales te permite escribir código más flexible y seguro en cuanto a tipos.
Otras extensiones