TypeScript Academy · Lección

Tipos de literales de cadenas y números

Restrinja los valores a cadenas y números exactos mediante tipos literales.

Tipos de literales de cadenas y números 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.

¿Qué es un tipo literal?

La mayoría de los tipos describen un conjunto de valores. string significa cualquier cadena y number, cualquier número. Un tipo literal lo restringe a un único valor exacto.

El tipo 'north' solo permite la cadena 'north', y nada más. Los tipos literales permiten modelar conjuntos precisos y finitos de valores permitidos directamente en el sistema de tipos.

let dir: 'north' = 'north';
console.log(dir);
// dir = 'south'; // Error: not assignable to type 'north'

Uniones de literales de cadena

Un único literal no resulta muy útil por sí solo. Combine varios con | para formar una unión de literales. Esta es la forma idiomática de modelar un conjunto fijo de opciones.

Direction solo puede ser una de cuatro cadenas exactas.

type Direction = 'north' | 'south' | 'east' | 'west';

let heading: Direction = 'east';
console.log('Heading:', heading);

heading = 'west';
console.log('Now:', heading);

Rechazo de valores no válidos

La ventaja de las uniones de literales es que el compilador rechaza cualquier valor que esté fuera del conjunto permitido. Los errores tipográficos y las opciones no válidas se convierten en errores de compilación en lugar de errores en tiempo de ejecución.

type Direction = 'north' | 'south' | 'east' | 'west';

let heading: Direction = 'north';
console.log(heading);
// heading = 'up'; // Error: '"up"' is not assignable to 'Direction'

Literales como parámetros de funciones

Use uniones de literales para los parámetros de funciones que solo acepten valores específicos. Quien realice la llamada obtendrá autocompletado y no podrá pasar valores no válidos.

type Direction = 'north' | 'south' | 'east' | 'west';

function move(dir: Direction): string {
  return 'Moving ' + dir;
}

console.log(move('south'));
// console.log(move('left')); // Error

Tipos literales numéricos

Los tipos literales no son solo para cadenas. También puede usar números exactos. Un ejemplo clásico es un dado de seis caras, cuyo valor debe ser uno de 1 a 6.

type Dice = 1 | 2 | 3 | 4 | 5 | 6;

function roll(): Dice {
  return (Math.floor(Math.random() * 6) + 1) as Dice;
}

console.log('Rolled:', roll());

Literales numéricos en parámetros

Las uniones de literales numéricos restringen las entradas a un conjunto exacto de números; son perfectas para niveles de calidad, códigos similares a los HTTP o tamaños de cuadrícula.

type Quality = 1 | 2 | 3;

function setQuality(level: Quality): void {
  console.log('Quality set to', level);
}

setQuality(2);
// setQuality(5); // Error: 5 is not 1 | 2 | 3

Combinación de literales de cadena y numéricos

Una unión puede combinar distintos tipos de literales. Esto resulta útil para APIs que aceptan un ajuste predefinido con nombre o un valor sin procesar.

type Size = 'small' | 'large' | 0 | 100;

function resize(s: Size): void {
  console.log('Resizing to', s);
}

resize('small');
resize(100);

Tipos literales booleanos

Los booleanos también tienen tipos literales: true y false son tanto tipos como valores. El tipo completo boolean no es más que true | false.

type AlwaysOn = true;

let enabled: AlwaysOn = true;
console.log('Enabled:', enabled);
// enabled = false; // Error: false not assignable to true

Los literales mejoran la documentación

Una unión de literales también sirve como documentación. Cualquiera que lea type Status = 'idle' | 'loading' | 'done' sabe de inmediato todos los estados posibles: no hay que adivinar ni buscar cadenas mágicas dispersas por el código.

type Status = 'idle' | 'loading' | 'done';

function render(s: Status): string {
  return 'State is: ' + s;
}

console.log(render('loading'));

Combinación de literales con otros tipos

Puede combinar tipos literales con tipos más generales en una unión. Un patrón habitual es 'auto' | number, que significa que se acepta la palabra clave especial 'auto' o cualquier número.

type Width = 'auto' | number;

function setWidth(w: Width): void {
  console.log('Width:', w);
}

setWidth('auto');
setWidth(320);

Literales como constantes con nombre

Los tipos literales combinan muy bien con las constantes con nombre. Defina el tipo una vez, reutilícelo en todas partes y refactorice con seguridad. El compilador mantiene la coherencia en todos los usos.

type Theme = 'light' | 'dark';

const DEFAULT_THEME: Theme = 'dark';

function applyTheme(t: Theme): void {
  console.log('Applying', t, 'theme');
}

applyTheme(DEFAULT_THEME);

Comprobación rápida

Compruebe su comprensión de los tipos literales.

Resumen: tipos literales

Ha aprendido que:

Los tipos literales representan un único valor exacto, por ejemplo, 'north' o 6.
Combinar literales con | crea una unión finita de valores permitidos.
Funcionan con cadenas, números y booleanos, y pueden combinarse con tipos más generales como 'auto' | number.
Cuando se usan como parámetros de funciones, ofrecen autocompletado y rechazan las entradas no válidas durante la compilación.

A continuación, veremos cómo decide TypeScript entre tipos literales y tipos ampliados.

type Direction = 'north' | 'south' | 'east' | 'west';
type Dice = 1 | 2 | 3 | 4 | 5 | 6;

function describe(d: Direction, n: Dice): string {
  return 'Go ' + d + ' ' + n + ' steps';
}

console.log(describe('north', 3));

Preguntas frecuentes

¿La lección «Tipos de literales de cadenas y números» es gratis?

Sí — el texto completo de «Tipos de literales de cadenas y números» 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 «Tipos de literales de cadenas y números»?

Restrinja los valores a cadenas y números exactos mediante tipos literales. 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 «Tipos de literales de cadenas y números»?

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

Tipos de literales de cadenas y números
Literales booleanos e inferencia de literales
Aserciones const con as const
Combinación de literales en uniones

← Volver a TypeScript Academy