Uso de Alias en TypeScript

Un Alias de tipo en TypeScript nos permite crear un nombre alternativo para un tipo específico (ya sea estándard, o definido por nosotros).

Los alias son una gran ayuda para mejorar la legibilidad del código. Son especialmente útiles cuando trabajamos con tipos complejos (como uniones, intersecciones y tipos personalizados).

Creación de un alias

Para crear un alias de tipo se utiliza la palabra clave type seguida del nombre del alias y la definición del tipo.

type NombreAlias = Tipo;

Por ejemplo así,

type ID = number;        // ahora ID es un alias de number
type Nombre = string;    // Nombre es un alias de string

let usuarioID: ID = 123;
let usuarioNombre: Nombre = "Luis Pérez";

console.log(usuarioID); // 123
console.log(usuarioNombre); // Luis Pérez

Alias con tipos compuestos

Los alias de tipo son especialmente útiles cuando se combinan tipos mediante uniones o intersecciones.

Alias con uniones

En el ejemplo siguiente, Resultado es un tipo que puede ser o una cadena de texto (string) o un número (number).

// Definimos un alias de tipo 'Resultado' que puede ser una cadena de texto o un número
type Resultado = string | number;

// Creamos una variable 'valor1' con un texto, y valor2 con un numero
let valor1: Resultado = "Éxito";
let valor2: Resultado = 200;

console.log(valor1); // Éxito
console.log(valor2); // 200

Alias con intersecciones

En este ejemplo UsuarioEmpleado es un tipo que combina dos interfaces: Usuario y Empleado. Esto significa que cualquier objeto de tipo UsuarioEmpleado debe tener todas las propiedades definidas en ambas interfaces.

// Definimos una interfaz 'Usuario' con propiedades 'nombre' y 'email'
interface Usuario {
    nombre: string;
    email: string;
}

// Definimos una interfaz 'Empleado' con propiedades 'empleadoID' y 'departamento'
interface Empleado {
    empleadoID: number;
    departamento: string;
}

// Creamos un alias de tipo 'UsuarioEmpleado' que combina las interfaces 'Usuario' y 'Empleado'
type UsuarioEmpleado = Usuario & Empleado;

// Creamos un objeto 'empleado' que debe cumplir con ambas interfaces: 'Usuario' y 'Empleado'
const empleado: UsuarioEmpleado = {
    nombre: "Ana García",
    email: "ana.garcia@example.com",
    empleadoID: 101,
    departamento: "Desarrollo"
};

console.log(empleado.nombre); // Ana García
console.log(empleado.departamento); // Desarrollo

Alias con literales

// Definimos un tipo literal 'Estado' que puede ser solo uno de los valores específicos
type Estado = 'activo' | 'inactivo' | 'pendiente';

// Creamos una variable 'estadoUsuario' del tipo 'Estado' 
let estadoUsuario: Estado = 'activo';
console.log(estadoUsuario); // activo

// Cambiamos el valor de 'estadoUsuario' a otro valor válido
estadoUsuario = 'pendiente';
console.log(estadoUsuario); // pendiente

// Intentar asignar un valor no permitido causará un error de compilación
estadoUsuario = 'suspendido'; // Error: Type '"suspendido"' is not assignable to type 'Estado'.

Alias con tipos de funciones

Los alias de tipo también pueden utilizarse para definir tipos de funciones,

type Operacion = (a: number, b: number) => number;

const sumar: Operacion = (a, b) => a + b;
const restar: Operacion = (a, b) => a - b;

console.log(sumar(5, 3)); // 8
console.log(restar(5, 3)); // 2

En este ejemplo, Operacion es un alias para cualquier función que tome dos números como parámetros y retorne un número.

Alias con tipos genéricos

Los alias de tipo pueden definirse utilizando parámetros genéricos,

type Respuesta<T> = {
    exito: boolean;
    datos: T;
    mensaje?: string;
};

const respuesta1: Respuesta<string> = {
    exito: true,
    datos: "Operación exitosa"
};

const respuesta2: Respuesta<number> = {
    exito: false,
    datos: 0,
    mensaje: "Error en la operación"
};

console.log(respuesta1.datos); // Operación exitosa
console.log(respuesta2.mensaje); // Error en la operación

En este ejemplo, Respuesta es un alias de tipo genérico que puede adaptarse a diferentes tipos de datos.

Alias y tipos avanzados

Alias y tipos condicionales

Los alias pueden combinarse con tipos condicionales para crear tipos más dinámicos y adaptativos.

type TipoTexto<T> = T extends string ? "Es una cadena" : "No es una cadena";

type ResultadoTexto = TipoTexto<string>; // Es una cadena
type ResultadoNumero = TipoTexto<number>; // No es una cadena

Alias y tipos de mapeo

Los alias pueden usarse con tipos de mapeo para transformar otros tipos.

type Opcional<T> = {
    [P in keyof T]?: T[P];
};

interface Usuario {
    nombre: string;
    email: string;
}

type UsuarioOpcional = Opcional<Usuario>;

const usuario: UsuarioOpcional = {
    nombre: "Carlos"
};

console.log(usuario.nombre); // Carlos
console.log(usuario.email); // undefined