Los tipos como lenguaje de computación
Comprenda el sistema de tipos como un lenguaje funcional puro.
Los tipos como lenguaje de computación es una lección gratuita de TypeScript Academy en CoddyKit. Esta es la lección 1 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de TypeScript Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de TypeScript Academy incluye 4 lecciones en total.
Los tipos son un lenguaje
TypeScript tiene dos lenguajes que conviven. Uno es el JavaScript del nivel de valores que ya conoce. El otro es el nivel de tipos, que se ejecuta completamente durante la compilación. En este curso aprenderá a programar en ese segundo lenguaje.
El sistema de tipos es un pequeño lenguaje funcional y puro. Se le proporcionan tipos como entrada y calcula tipos como salida. Nada de esto llega a la ejecución.
type Greeting = "hello";
type Loud = Uppercase<Greeting>;
// Loud is "HELLO" - computed by the type systemTipos de entrada, tipos de salida
Un tipo genérico es, esencialmente, una función de tipos a tipos. El parámetro de tipo es el argumento y el cuerpo es el valor de retorno.
A continuación, Boxed recibe un tipo T y produce un tipo de objeto que lo envuelve. Piense en T como un parámetro que proporciona.
type Boxed<T> = { value: T };
type A = Boxed<number>; // { value: number }
type B = Boxed<string>; // { value: string }Los genéricos son funciones
Compare una función del nivel de valores con una del nivel de tipos. Las estructuras son prácticamente idénticas: entran parámetros y sale un único resultado.
- Valor:
const id = (x) => x - Tipo:
type Id<T> = T
El Id del nivel de tipos simplemente devuelve lo que se le proporcione.
type Id<T> = T;
type X = Id<boolean>; // boolean
type Y = Id<"abc">; // "abc"Sin coste en tiempo de ejecución
Todo lo que pertenece al nivel de tipos se elimina antes de que se ejecute el código. La salida de JavaScript no contiene ningún rastro de los cálculos de tipos. El programa en ejecución no tiene ningún coste de rendimiento, por más elaborados que sean los tipos.
Por eso, a veces la programación en el nivel de tipos se denomina gratuita: solo afecta al compilador, nunca al bundle.
type Pair<T> = [T, T];
const p: Pair<number> = [1, 2];
// Compiled JS is just: const p = [1, 2];
console.log(p);Varios parámetros
Las funciones del nivel de tipos pueden recibir varios parámetros, igual que las funciones normales. Aquí, Merge recibe dos tipos de objeto y los combina.
Se puede leer así: dados A y B, devuelve un objeto que tiene todas las propiedades de ambos.
type Merge<A, B> = A & B;
type User = { id: number };
type Named = { name: string };
type NamedUser = Merge<User, Named>;
// { id: number; name: string }Valores predeterminados de los parámetros
Los parámetros de tipo pueden tener valores predeterminados, igual que los argumentos predeterminados de una función. Si quien realiza la llamada omite el argumento, se utiliza el valor predeterminado.
type List<T = string> = T[];
type A = List; // string[]
type B = List<number>; // number[]Las restricciones actúan como guardas
Una restricción con extends limita los tipos que se pueden pasar. Es el equivalente a nivel de tipos de validar un argumento de función antes de utilizarlo.
HasId solo acepta tipos que ya tienen una propiedad id, por lo que el cuerpo puede leerla de forma segura.
type GetId<T extends { id: number }> = T["id"];
type A = GetId<{ id: number; name: string }>; // number
// GetId<{ name: string }> would be a compile errorCálculo, no solo anotación
Los principiantes utilizan los tipos únicamente para etiquetar valores. La programación a nivel de tipos utiliza los tipos para calcular resultados. Por ejemplo, la utilidad integrada ReturnType inspecciona un tipo de función y extrae su tipo de resultado.
type Fn = (a: number) => string;
type R = ReturnType<Fn>; // string
type Fn2 = () => boolean;
type R2 = ReturnType<Fn2>; // booleanMapeo de propiedades
Los tipos mapeados permiten transformar cada propiedad de un tipo de objeto. Esto es un bucle en el lenguaje de tipos. Stringify convierte cada tipo de valor en string.
type Stringify<T> = { [K in keyof T]: string };
type Input = { a: number; b: boolean };
type Out = Stringify<Input>; // { a: string; b: string }Puro y determinista
El lenguaje de tipos es puro: las mismas entradas siempre producen el mismo tipo de salida, sin efectos secundarios. No hay mutación, E/S ni dependencia del tiempo. Esta pureza hace que los programas a nivel de tipos sean predecibles y componibles.
Gracias a la pureza, puede razonar sobre los tipos como razona sobre las matemáticas: mediante sustitución.
type Square<T extends { area: number }> = T["area"];
// Always the same result for the same input shapePor qué es importante
Dominar este segundo lenguaje le permite codificar reglas que el compilador aplica de forma gratuita: rutas válidas, instrucciones switch exhaustivas, manipulación segura de cadenas y API que no se pueden utilizar incorrectamente. El resto de este curso desarrolla el conjunto de herramientas.
Idea clave: un tipo es un valor en el lenguaje de tipos y un genérico es una función.
type NonEmpty<T extends unknown[]> =
T extends [unknown, ...unknown[]] ? T : never;
// Encodes a rule: the tuple must have at least one elementComprobación rápida
Compruebe cuánto entiende de los tipos como lenguaje de cálculo.
Resumen
Ha aprendido que los tipos de TypeScript forman un lenguaje funcional puro que se ejecuta en tiempo de compilación.
- Los genéricos son funciones: reciben tipos y devuelven tipos.
- Los parámetros admiten valores predeterminados y restricciones con
extends. - Los tipos mapeados recorren las propiedades.
- Todo se elimina, por lo que no hay coste en tiempo de ejecución.
A continuación, añadirá una instrucción if a este lenguaje: los tipos condicionales.
Preguntas frecuentes
¿La lección «Los tipos como lenguaje de computación» es gratis?
Sí — el texto completo de «Los tipos como lenguaje de computación» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de TypeScript Academy, actualiza a CoddyKit PRO. El curso de TypeScript Academy incluye 4 lecciones en total.
¿Qué aprenderé en «Los tipos como lenguaje de computación»?
Comprenda el sistema de tipos como un lenguaje funcional puro. Practicas TypeScript Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar TypeScript Academy?
No se requiere experiencia previa. TypeScript Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 4.
¿Cuánto tiempo toma la lección «Los tipos como lenguaje de computación»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de TypeScript Academy?
Sí. Cada lección de TypeScript Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- Los tipos como lenguaje de computación
- Condicionales a nivel de tipos
- Recursión a nivel de tipos
- Tipos condicionales distributivos