Tipos vs Interfaces en TypeScript: cuándo usar cada uno
Types e interfaces: parecen iguales, pero no lo son
Si estás empezando con TypeScript (o incluso si ya llevas tiempo), es muy probable que te hayas hecho esta pregunta:
¿Uso
typeointerface?
Ambos sirven para definir la forma de un objeto. Ambos funcionan. Ambos compilan.
Entonces… ¿da lo mismo?
La respuesta corta es: no. La respuesta útil es: depende del contexto.
El punto en común: describir estructuras
Tanto type como interface permiten definir la estructura de un objeto:
type UserType = {
id: number;
email: string;
};
interface UserInterface {
id: number;
email: string;
}En este punto, son equivalentes. Si solo miras esto, parece una discusión innecesaria.
Pero TypeScript no se trata solo de escribir tipos, sino de cómo esos tipos evolucionan con tu código.
La primera gran diferencia: extensión
Extender interfaces
Las interfaces están pensadas para ser extendidas.
interface User {
id: number;
email: string;
}
interface AdminUser extends User {
role: "admin";
}Este patrón es muy común cuando modelas dominios o jerarquías claras.
Extender types
Los type se extienden usando intersecciones:
type User = {
id: number;
email: string;
};
type AdminUser = User & {
role: "admin";
};Funciona igual, pero semánticamente comunica algo distinto.
Interfaces pueden fusionarse (y eso importa)
Esta es una diferencia clave.
Las interfaces soportan declaration merging:
interface User {
id: number;
}
interface User {
email: string;
}El resultado final es:
interface User {
id: number;
email: string;
}Esto es muy útil cuando:
- trabajas con librerías
- extiendes tipos globales
- haces augmentations (por ejemplo, en Express o Window)
Los type no permiten esto.
Types son más expresivos
Aquí es donde type brilla.
Los type pueden representar cosas que las interfaces no:
Union types
type Status = "idle" | "loading" | "success" | "error";Tipos primitivos y compuestos
type ID = string | number;Tuplas
type Point = [number, number];Si necesitas algo que no sea estrictamente un objeto, type es la herramienta correcta.
Entonces… ¿cuándo usar cada uno?
Usa interface cuando:
- defines la forma de objetos
- modelas entidades del dominio
- esperas que ese contrato se extienda
- trabajas con clases
- necesitas declaration merging
Usa type cuando:
- necesitas unions
- defines estados o variantes
- trabajas con tipos primitivos
- compones tipos con lógica más compleja
Un criterio práctico (regla simple)
Una regla que funciona muy bien en proyectos reales:
- interfaces para objetos
- types para todo lo demás
No es una ley, pero evita discusiones innecesarias y mantiene el código consistente.
Un error común: mezclar sin criterio
No hay nada peor que ver esto:
- interfaces usadas para unions
- types usados solo por costumbre
- decisiones distintas en cada archivo
La consistencia es más importante que la elección perfecta.
Conclusión
type e interface no compiten: se complementan.
Elegir bien no hace que tu código compile mejor, pero sí hace que:
- sea más legible
- evolucione mejor
- sea más fácil de mantener
Y en proyectos reales, eso es lo que realmente importa.