TypeScript
Comparación entre type aliases e interfaces para modelar objetos, unions y contratos extensibles, con sus diferencias prácticas dentro de TypeScript.
e permiten nombrar contratos. Se superponen en muchos usos, pero no son idénticos.
typeinterfacetype Product = {
id: string;
name: string;
};interface Product {
id: string;
name: string;
}Un alias puede nombrar cualquier tipo:
type Identifier = string | number;
type Coordinates = readonly [x: number, y: number];
type ProductMap = Record<string, Product>;
type Loader = (id: string) => Promise<Product>;También puede describir objetos.
Una interface declara principalmente una forma de objeto, función o constructor.
interface ProductRepository {
findById(id: string): Promise<Product | undefined>;
save(product: Product): Promise<void>;
}interface Cart {
add(item: CartItem): void;
remove(itemId: string): void;
calculateTotal(): number;
}Definir métodos en interfaces es completamente normal. Una interface expresa un contrato; no obliga a utilizar una clase.
const cart: Cart = createCart();interface Formatter {
(value: number): string;
}Es válido, aunque un type alias suele ser más directo para una firma simple:
type Formatter = (value: number) => string;interface ProductConstructor {
new (id: string, name: string): Product;
}interface Entity {
id: string;
}
interface Product extends Entity {
name: string;
price: number;
}Una interface puede extender varias interfaces:
interface AuditedProduct
extends Product, Timestamped {}La afirmación “los types no pueden expandirse” es incorrecta.
type Entity = {
id: string;
};
type Product = Entity & {
name: string;
price: number;
};También pueden derivarse mediante generics, mapped types y conditional types.
type Named = {
name: string;
};
interface User extends Named {
email: string;
}Funciona cuando el alias representa una forma de objeto conocida estáticamente. Una interface no puede extender directamente una union.
type Result = Success | Failure;
interface ExtendedResult extends Result {}Esto no es válido porque una union no tiene una forma única fija.
interface Product {
id: string;
}
type ProductPreview = Product & {
selected: boolean;
};Ambos sistemas se combinan.
Dos interfaces con el mismo nombre en el mismo scope pueden fusionarse.
interface Window {
applicationVersion: string;
}
interface Window {
currentUser?: User;
}El resultado contiene ambos miembros.
Los type aliases no se redeclaran:
type Product = { id: string };
type Product = { name: string };Produce un error de identificador duplicado.
Declaration merging aporta para:
En modelos de dominio internos puede ocultar dónde se añadió una propiedad. Usa nombres únicos y módulos claros.
interface Settings {
theme: string;
}
interface Settings {
theme: number;
}Las propiedades no funcionales deben tener tipos compatibles.
Los métodos pueden formar overloads durante el merge.
interface Product {
readonly id: string;
description?: string;
}Tienen el mismo significado estático que en object type aliases.
interface Scores {
[playerId: string]: number;
}interface Repository<TEntity> {
findById(id: string): Promise<TEntity | undefined>;
save(entity: TEntity): Promise<void>;
}class InMemoryProductRepository
implements ProductRepository {
async findById(id: string) {
return products.get(id);
}
async save(product: Product) {
products.set(product.id, product);
}
}implements comprueba el lado de instancia de la clase. No copia código ni cambia el prototipo.
Interfaces no son “más apropiadas para HTTP” por definición.
type ProductResponse = {
id: string;
price_in_cents: number;
};Podría ser type o interface. Lo importante es:
Suele ser natural para:
Suele ser natural para:
Estas son tendencias, no prohibiciones.
Si ambos sirven, sigue la convención del proyecto. Cambiar entre type e interface sin una razón no mejora el sistema.
interface PaymentGateway {
charge(input: ChargeInput): Promise<ChargeResult>;
}
type ChargeResult =
| { status: "approved"; paymentId: string }
| { status: "rejected"; reason: string };La interface expresa una capacidad implementable. El type expresa variantes cerradas de resultado.
¿Por qué type Status = "idle" | "loading" no puede reemplazarse directamente por una interface?
Porque una interface describe una forma de objeto, llamada o constructor; no puede representar directamente una union de valores primitivos literales.
Extensión, intersections y declaration merging compara las distintas formas de ampliar contratos y sus conflictos.