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 Fondo Título Cómo funcionan los tipos condicionales Explicación de la sintaxis Sintaxis de tipos condicionales T extends U ? X : Y Flecha Flujo de ejecución Flujo de ejecución Comprobar si T se puede asignar a U → Sí → X | No → Y Área de ejemplo Análisis del ejemplo Ejemplo 1 Ejemplo 1 IsString<string> string extends string? ✓ → true Ejemplo 2 Ejemplo 2 IsString<number> number extends string? ✗ → false Ejemplo 3 Ejemplo 3 ReturnType<fn> fn extends (...args) → R (tipo de retorno inferido) Marcador de flecha

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 esT 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

// Sintaxis de tipo condicional: T extends U ? X : Y
// 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

// Usando el tipo condicional para implementar NonNullable
// 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

// Usando infer para inferir el tipo de retorno de una función
// 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

// ToArray convierte el tipo T en un tipo de array
// 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

// Define la interfaz de usuario
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

// Comprueba si el tipo es any
// 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