Uso de Literales en TypeScript

En TypeScript, los tipos literales son tipos que permiten definir variables con valores específicos y prefijados en lugar de tipos amplios como string o number.

El motivo principal es permitirnos un mayor control y seguridad sobre los valores que puede tomar una variable, limitando las opciones disponibles.

Tipos literales de cadena

Los tipos literales de cadena permiten definir una variable que solo puede tener uno de varios valores específicos de cadena.

type Direccion = "norte" | "sur" | "este" | "oeste";

let direccion: Direccion;

direccion = "norte"; // Correcto
direccion = "sur";   // Correcto
// direccion = "noreste"; // Error: El tipo '"noreste"' no se puede asignar al tipo 'Direccion'.

Tipos literales numéricos

Similar a los literales de cadena, los tipos literales numéricos permiten que una variable tenga solo ciertos valores numéricos específicos.

type UnoADiez = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10;

let numero: UnoADiez;

numero = 1;  // Correcto
numero = 5;  // Correcto
// numero = 11; // Error: El tipo '11' no se puede asignar al tipo 'UnoADiez'.

Literales y tipos unión

Los tipos literales se utilizan frecuentemente junto con los tipos unión para crear variables que pueden aceptar varios valores específicos.

type Respuesta = "sí" | "no" | "tal vez";

function contestar(respuesta: Respuesta): void {
    console.log(`La respuesta es: ${respuesta}`);
}

contestar("sí");      // Correcto
contestar("no");      // Correcto
contestar("tal vez"); // Correcto
// contestar("quizás"); // Error: El tipo '"quizás"' no se puede asignar al tipo 'Respuesta'.

Literales y tipos personalizados

Los tipos literales también pueden ser utilizados en la definición de tipos personalizados más complejos, proporcionando mayor control sobre los valores de las propiedades de los objetos.

type Estado = "iniciado" | "en progreso" | "completado";

interface Tarea {
    titulo: string;
    descripcion: string;
    estado: Estado;
}

let tarea: Tarea = {
    titulo: "Aprender TypeScript",
    descripcion: "Estudiar los tipos literales en TypeScript.",
    estado: "en progreso"
};

// tarea.estado = "pendiente"; // Error: El tipo '"pendiente"' no se puede asignar al tipo 'Estado'.

Literales de plantilla

TypeScript soporta literales de plantilla para crear tipos literales de cadena a partir de combinaciones de otros tipos literales.

type Prefijo = "Sr." | "Sra." | "Srta.";
type NombreCompleto = `${Prefijo} ${string}`;

let persona1: NombreCompleto = "Sr. Luis Pérez";
let persona2: NombreCompleto = "Sra. Ana Gómez";
// let persona3: NombreCompleto = "Doctor Luis Pérez"; // Error: El tipo '"Doctor Luis Pérez"' no se puede asignar al tipo 'NombreCompleto'.

Utilizar literales constantes

Cuando sea apropiado, utiliza literales constantes para definir valores específicos que no deben cambiar.

const ESTADO_ACTIVO = "activo";
const ESTADO_INACTIVO = "inactivo";

type Estado = typeof ESTADO_ACTIVO | typeof ESTADO_INACTIVO;

let estadoUsuario: Estado = ESTADO_ACTIVO;

Ejemplos Prácticos

Validación de parámetros con tipos literales

type MetodoHttp = "GET" | "POST" | "PUT" | "DELETE";

function hacerPeticion(url: string, metodo: MetodoHttp): void {
    console.log(`Haciendo petición a ${url} con método ${metodo}`);
}

hacerPeticion("https://api.example.com", "GET");    // Correcto
hacerPeticion("https://api.example.com", "POST");   // Correcto
// hacerPeticion("https://api.example.com", "PATCH"); // Error: El tipo '"PATCH"' no se puede asignar al tipo 'MetodoHttp'.

Configuración de opciones con literales

type Modo = "oscuro" | "claro";

interface Configuracion {
    tema: Modo;
    notificaciones: boolean;
}

let config: Configuracion = {
    tema: "oscuro",
    notificaciones: true
};

function cambiarTema(config: Configuracion, nuevoTema: Modo): Configuracion {
    config.tema = nuevoTema;
    return config;
}

config = cambiarTema(config, "claro"); // Correcto
// config = cambiarTema(config, "auto"); // Error: El tipo '"auto"' no se puede asignar al tipo 'Modo'.