let x: number = 10 Tipo number
let s: string = "hello" Tipo string
let b: boolean = true Tipo boolean
let arr: number[] = [1, 2, 3] Tipo array
let tuple: [string, number] Tipo tupla (longitud y tipos fijos)
let x: any Tipo any (sin verificación de tipos)
let x: unknown Tipo unknown (más seguro que any)
let x: never Tipo never (código inalcanzable)
let x: void Tipo void (sin valor de retorno)
let x: null | undefined Tipos null y undefined
type ID = string | number Tipo unión
type Point = { x: number; y: number } Alias de tipo para objeto
const x = "hello" as const Aserción const (tipo literal)
interface User {
name: string;
age: number;
} Declaración de interfaz
interface User {
email?: string;
} Propiedad opcional
interface User {
readonly id: number;
} Propiedad de solo lectura
interface Admin extends User {
role: string;
} Herencia de interfaz
interface Fn {
(x: number): string;
} Interfaz invocable
interface Dict {
[key: string]: number;
} Firma de índice
interface A extends B, C {} Herencia múltiple
function identity<T>(arg: T): T {
return arg;
} Función genérica
interface Box<T> {
value: T;
} Interfaz genérica
class Container<T> {
constructor(public value: T) {}
} Clase genérica
function fn<T extends HasLength>(x: T) Restricción genérica
function fn<T, K extends keyof T>(obj: T, key: K) Restricción keyof
type Pair<T, U = T> = [T, U] Genérico con tipo por defecto
function fn<T extends string | number>(x: T) Restricción de unión
Partial<User> Hacer todas las propiedades opcionales
Required<User> Hacer todas las propiedades requeridas
Readonly<User> Hacer todas las propiedades de solo lectura
Pick<User, "name" | "age"> Seleccionar subconjunto de propiedades
Omit<User, "password"> Omitir propiedades específicas
Record<string, number> Tipo objeto con tipos clave/valor
ReturnType<typeof fn> Extraer tipo de retorno de función
Parameters<typeof fn> Extraer tipos de parámetros de función
Awaited<Promise<string>> Desenvolver tipo Promise
NonNullable<string | null> Eliminar null/undefined del tipo
Extract<A | B | C, A | B> Extraer miembros coincidentes de la unión
Exclude<A | B | C, A> Eliminar miembros coincidentes de la unión
if (typeof x === "string") Guardia typeof
if (x instanceof Date) Guardia instanceof
if ("name" in obj) Guardia con operador in
function isUser(x: any): x is User {
return "name" in x;
} Predicado de tipo personalizado
x as string Aserción de tipo
x satisfies Type Operador satisfies (TS 4.9+)
enum Direction {
Up,
Down,
Left,
Right
} Enum numérico (0, 1, 2, 3)
enum Status {
Active = "ACTIVE",
Inactive = "INACTIVE"
} Enum de cadenas
const enum Color { Red, Green, Blue } Enum const (insertado en compilación)
type Keys = keyof User Obtener unión de claves del objeto
type Val = User["name"] Tipo de acceso indexado
type Mapped = {
[K in keyof T]: boolean
} Tipo mapeado
type IsString<T> = T extends string
? "yes" : "no" Tipo condicional
type Flatten<T> = T extends Array<infer U>
? U : T Palabra clave infer
type Literal = "a" | "b" | "c" Tipo unión de literales de cadena
declare module "lib" {
export function fn(): void;
} Declaración de módulo (ambient)
// @ts-ignore Suprimir error TS en la siguiente línea
// @ts-expect-error Esperar error en la siguiente línea
Cheat Sheet de TypeScript — Interfaces, Genéricos, Utility Types y Type Guards
TypeScript salió en 2012 como superset tipado de JavaScript; el sistema de tipos ha crecido bastante desde entonces —genéricos, tipos condicionales, `infer`, tipos de plantilla, `satisfies`— mientras que el runtime sigue siendo JavaScript puro sin comprobaciones. La chuleta de abajo cubre más de 55 patrones entre básicos, interfaces, genéricos, utility types, type guards, enums y avanzados. La mayoría de los líos en código TypeScript real no vienen de olvidar la sintaxis. Vienen de rarezas que parecen normales pero muerden. `any` y `unknown` se parecen pero se comportan de forma opuesta: `any` desactiva el chequeo, mientras que `unknown` exige una comprobación de narrowing antes de poder usarse. El cast con `as` le dice al compilador que se fíe y desactiva la comprobación en esa línea sin avisar. El tipado estructural hace que dos tipos con la misma forma sean intercambiables, lo que sorprende a quien viene de Java o C#. Estos son los fragmentos que se acaban consultando al depurar precisamente eso: el predicado de narrowing correcto, el utility type adecuado, la restricción de genérico apropiada, sin releer la referencia desde la línea uno cada vez.
Trampas habituales en TypeScript
Hay un puñado de patrones que merecen estar en la primera pantalla de cualquier archivo de TypeScript. Conviene tirar de `unknown` antes que de `any` cuando la forma del valor no esté clara: `unknown` mantiene el sistema de tipos activo y obliga a una comprobación (`typeof`, `instanceof` o un predicado) antes de acceder a una propiedad. `satisfies` suele preferirse frente a una anotación al asignar una constante: valida la forma manteniendo el tipo literal estrecho. `--strictNullChecks` convierte `null` y `undefined` en tipos distintos que hay que excluir con encadenamiento opcional, el operador `??` o un type guard; sin el flag, ambos se cuelan en cada tipo sin avisar. Las aserciones con `as` deberían ser el último recurso: un predicado `x is User` es verificable, mientras que `x as User` es una promesa que el compilador acepta sin pruebas. Las firmas de índice `[key: string]: T` aceptan lecturas de claves inexistentes, y solo devuelven `T | undefined` cuando se activa `--noUncheckedIndexedAccess`. La chuleta agrupa esto en Basic Types, Interfaces, Generics, Utility Types, Type Guards, Enums y Advanced para que la sección adecuada esté a un clic.
- Más de 55 patrones de tipos TypeScript
- 7 categorías desde básicos hasta avanzado
- Todos los tipos de utilidad cubiertos
- Patrones genéricos y restricciones
- Copia al portapapeles con un clic
- Cubre funcionalidades de TypeScript 5.x
Gratis. Sin registro. Tus datos permanecen en tu navegador. Anuncios mediante Google AdSense (con consentimiento).
Por Marco B. ·