TypeScript
Diferencias entre extender interfaces, combinar tipos mediante intersections y aprovechar declaration merging al modelar contratos en TypeScript.
TypeScript ofrece varias formas de ampliar contratos, pero cada una expresa una intención distinta.
interface extends → herencia estructural abierta
intersection & → combinación de restricciones
merging → declaraciones con el mismo nombre se unen
augmentation → ampliar un módulo o global existenteinterface Entity {
id: string;
}
interface Product extends Entity {
name: string;
}La interface hija debe mantener miembros compatibles.
interface Named {
value: string;
}
interface Numeric {
value: number;
}
interface Invalid extends Named, Numeric {}TypeScript detecta inmediatamente que value no puede heredarse con tipos incompatibles.
type Combined = Named & Numeric;Puede crearse, pero Combined["value"] resulta never. El conflicto aparece al usar el tipo.
Usa extends cuando modelas una relación de contrato clara entre object types.
Usa & cuando:
interface ApplicationConfig {
apiUrl: string;
}
interface ApplicationConfig {
timeout: number;
}El resultado incluye ambos miembros.
type ApplicationConfig = {
apiUrl: string;
};No puede redeclararse con el mismo nombre. Esto ayuda cuando quieres que el contrato tenga un único origen visible.
interface Parser {
parse(value: string): Product;
}
interface Parser {
parse(value: ArrayBuffer): Product;
}Los métodos forman overloads.
Las declaraciones posteriores pueden tener prioridad en grupos de overloads, con reglas especiales para firmas literales. No diseñes una API cuyo comportamiento dependa de un orden de archivos difícil de seguir.
Una namespace puede fusionarse con una clase, función o enum para añadir miembros estáticos o tipos relacionados.
function buildProduct() {}
namespace buildProduct {
export type Options = {
validate: boolean;
};
}Este patrón existe en APIs históricas, pero para código moderno suelen ser más claros módulos y exports separados.
import "some-library";
declare module "some-library" {
interface Client {
traceId?: string;
}
}La declaración amplía el tipo del módulo existente. Debe coincidir con una modificación runtime real o con una capacidad ya presente que las declaraciones omitían.
declare module "some-library" {
interface Client {
reset(): void;
}
}Si el objeto real no tiene reset, el código compilará pero fallará al ejecutar.
export {};
declare global {
interface Window {
applicationVersion: string;
}
}El export {} convierte el archivo en módulo y declare global abre explícitamente el global.
Interfaces globales como Window, HTMLElementTagNameMap o APIs de plugins se benefician de ser ampliables.
Los modelos del dominio suelen beneficiarse de contratos cerrados y transformaciones explícitas.
type WithId<T> = T & {
id: string;
};function addId<T extends object>(value: T): WithId<T> {
return {
...value,
id: crypto.randomUUID(),
};
}TypeScript no tiene un operador de “sobrescribir” propiedades mediante &.
type Replace<T, TReplacement> =
Omit<T, keyof TReplacement> & TReplacement;type EditableProduct = Replace<
Product,
{ id: number }
>;Esta transformación elimina primero los miembros reemplazados.
Intersections pueden mostrarse de forma poco legible en el editor.
type Simplify<T> = {
[K in keyof T]: T[K];
} & {};Ayuda a mostrar una forma final, pero no cambia su significado estructural.
interface ApplicationPlugins {}
interface ApplicationPlugins {
analytics: AnalyticsPlugin;
}
interface ApplicationPlugins {
notifications: NotificationPlugin;
}Este patrón permite que módulos independientes registren capacidades en un contrato abierto.
declare global.extends expresa herencia estructural de interfaces.& combina restricciones y no sobrescribe.¿Por qué A & { id: number } no reemplaza un id: string existente en A?
Porque la intersection exige cumplir ambos tipos simultáneamente; la propiedad terminaría como string & number, es decir, never.
keyof, typeof e indexed access types permite derivar tipos desde contratos existentes.