TypeScript
Uso de literal types, widening, as const y satisfies para conservar valores precisos, validar estructuras y evitar anotaciones que pierdan información.
TypeScript puede representar un valor exacto mediante un literal type.
type Status = "idle" | "loading" | "success";let direction: "left" | "right";
direction = "left";
direction = "right";Cada string del union es un tipo que contiene un solo valor.
También existen literales numéricos y booleanos:
type Dice = 1 | 2 | 3 | 4 | 5 | 6;
type Enabled = true;const fixedStatus = "idle";
let changingStatus = "idle";Tipos inferidos conceptualmente:
fixedStatus → "idle"
changingStatus → stringUn const no puede reasignarse, por lo que conservar el valor literal es seguro.
Un let puede recibir otros strings y normalmente se amplía.
const request = {
method: "GET",
};Aunque el binding request no puede reasignarse, la propiedad sí:
request.method = "POST";Por eso method suele inferirse como string, no como "GET".
const request: {
method: "GET" | "POST";
} = {
method: "GET",
};La anotación declara las opciones permitidas.
const request = {
method: "GET",
headers: ["Accept"],
} as const;El resultado se aproxima a:
{
readonly method: "GET";
readonly headers: readonly ["Accept"];
}as const:
No congela el objeto en runtime.
const headers = ["Accept"];
const request = {
method: "GET",
headers,
} as const;request.headers no puede reasignarse, pero el array externo continúa siendo mutable:
headers.push("Authorization");as const conserva la estructura literal; no crea una inmutabilidad profunda real sobre referencias que ya existían.
const method = "GET" as "GET";Funciona, pero suele ser redundante con const y puede esconder una mala inferencia si se utiliza indiscriminadamente.
type Routes = Record<string, string>;
const routes: Routes = {
home: "/",
products: "/products",
};La variable queda vista como Record<string, string>.
routes.home;Dependiendo del contrato, TypeScript puede perder conocimiento preciso de las claves concretas y tratarlas como strings dinámicos.
const routes = {
home: "/",
products: "/products",
} satisfies Record<string, string>;satisfies comprueba que el valor sea compatible sin reemplazar su tipo resultante por el tipo objetivo.
El checker conserva las claves conocidas:
routes.home;
routes.products;const configuration = {
retries: "3",
} satisfies {
retries: number;
};Produce un error. No convierte el string.
const value = externalValue as Product;as pide al checker aceptar una interpretación.
const value = {
id: "product-1",
} satisfies Product;satisfies verifica que una expresión conocida cumpla el contrato.
No se utiliza para validar un unknown recibido en runtime.
const palette: Record<string, string | number[]> = {
red: "#ff0000",
green: [0, 255, 0],
};El binding utiliza el tipo declarado.
const palette = {
red: "#ff0000",
green: [0, 255, 0],
} satisfies Record<string, string | number[]>;Comprueba el contrato y suele conservar más información específica de cada propiedad.
type RouteName = "home" | "products";
const routes = {
home: "/",
products: "/products",
settings: "/settings",
} satisfies Record<RouteName, string>;La clave adicional produce un error durante esta comprobación del literal.
type Role = "admin" | "customer" | "delivery";Para muchos estados simples, un union literal:
as const.enum tiene un contrato de emisión distinto y se estudiará por separado.
const roles = {
admin: "admin",
customer: "customer",
delivery: "delivery",
} as const;
type Role = typeof roles[keyof typeof roles];Resultado:
type Role = "admin" | "customer" | "delivery";La fuente runtime y el tipo pueden mantenerse alineados.
type RouteConfiguration = {
path: `/${string}`;
requiresAuthentication: boolean;
};
const routes = {
home: {
path: "/",
requiresAuthentication: false,
},
dashboard: {
path: "/dashboard",
requiresAuthentication: true,
},
} satisfies Record<string, RouteConfiguration>;El objeto se valida, pero conserva home y dashboard como claves conocidas.
const vuelve inmutable un objeto.as const esperando Object.freeze.satisfies con validación runtime.let suele ampliar literales mutables.as const conserva literales y añade readonly estático.as const no congela runtime.satisfies comprueba compatibilidad y conserva inferencia útil.¿Por qué const request = { method: "GET" } suele inferir method como string?
Porque const impide reasignar el binding request, pero la propiedad method continúa siendo mutable y podría recibir otro string.
Tipos básicos y tipos de propósito especial organiza los valores que el sistema puede representar y evita nombres engañosos como String u Object.