CAP 05 · LEC 02·TypeScript
Interfaces y type aliases
interface y type son las dos formas de nombrar estructuras de datos en TypeScript. Son más parecidos que diferentes — pero hay situaciones donde uno es claramente mejor que el otro.
¿Encontraste un error o algo que mejorar?Editá esta lección en GitHub →
interface
Una interface describe la forma de un objeto: qué propiedades tiene y de qué tipo son.
interface Usuario {
id: number;
nombre: string;
email: string;
edad?: number; // opcional
readonly creado: Date; // solo lectura — no se puede reasignar
}
// Cualquier objeto que cumpla la forma es válido
const ana: Usuario = {
id: 1,
nombre: "Ana",
email: "ana@mail.com",
creado: new Date(),
};
// ✅ edad es opcional — funciona sin ella
const luis: Usuario = {
id: 2,
nombre: "Luis",
email: "luis@mail.com",
creado: new Date(),
};
// ❌ Error: falta email
// const mal: Usuario = { id: 3, nombre: "Eva", creado: new Date() };type alias
type puede nombrar cualquier tipo — no solo objetos:
// Objeto (igual que interface)
type Punto = {
x: number;
y: number;
};
// Union
type Resultado = "ok" | "error" | "pendiente";
// Intersección
type AdminUsuario = Usuario & {
permisos: string[];
};
// Alias de primitivo
type Email = string;
type Timestamp = number;
// Función
type Comparador<T> = (a: T, b: T) => number;
const ordenarNombres: Comparador<string> = (a, b) => a.localeCompare(b);Extender interfaces
Las interfaces pueden extender otras — útil para crear jerarquías de tipos:
interface Entidad {
id: number;
creado: Date;
actualizado: Date;
}
interface Producto extends Entidad {
nombre: string;
precio: number;
stock: number;
}
interface ProductoConDescuento extends Producto {
descuento: number; // porcentaje 0-100
precioFinal: () => number;
}
const producto: ProductoConDescuento = {
id: 1,
nombre: "Camiseta",
precio: 29.99,
stock: 50,
descuento: 20,
creado: new Date(),
actualizado: new Date(),
precioFinal() {
return this.precio * (1 - this.descuento / 100);
},
};
console.log(producto.precioFinal().toFixed(2)); // "23.99"Salida
23.99interface vs type: diferencias clave
| interface | type | |
|---|---|---|
| Objetos | Sí — su uso principal | Sí |
| Primitivos, unions, tuples | No | Sí |
| Extender/heredar | extends — sintaxis clara | & (intersección) |
| Declaration merging | Sí — misma interface declarada dos veces se fusiona | No |
| Cuándo preferir | Objetos que representan entidades del dominio | Unions, tipos utilitarios, aliases de primitivos |
Guía práctica
Usa interface para describir objetos / clases. Usa type para unions, intersecciones, tuplas y aliases de primitivos. Si tienes dudas con un objeto, interface es el default más semántico.
Utility types más usados
TypeScript incluye tipos genéricos de utilidad que evitan repetir código:
interface Usuario {
id: number;
nombre: string;
email: string;
password: string;
}
// Partial<T> — todas las propiedades opcionales
type UsuarioParcial = Partial<Usuario>;
// { id?: number; nombre?: string; email?: string; password?: string }
// Required<T> — todas las propiedades obligatorias
type UsuarioCompleto = Required<UsuarioParcial>;
// Pick<T, K> — seleccionar algunas propiedades
type UsuarioPúblico = Pick<Usuario, "id" | "nombre" | "email">;
// Omit<T, K> — excluir algunas propiedades
type UsuarioSinPassword = Omit<Usuario, "password">;
// Readonly<T> — todas readonly
type UsuarioFijo = Readonly<Usuario>;
// Record<K, V> — objeto con claves y valores tipados
type PorId = Record<number, Usuario>;
// ReturnType<T> — infiere el tipo de retorno de una función
function getUser(): Usuario { /* ... */ return {} as Usuario; }
type TipoRetorno = ReturnType<typeof getUser>; // Usuario