TypeScript
Uso de implements y abstract classes para expresar contratos, compartir comportamiento y obligar a las subclases a completar operaciones específicas.
interface ProductRepository {
findById(id: string): Promise<Product | undefined>;
save(product: Product): Promise<void>;
}
class InMemoryProductRepository
implements ProductRepository {
async findById(id: string) {
return products.get(id);
}
async save(product: Product) {
products.set(product.id, product);
}
}implements no copia métodos ni cambia el prototipo.
interface Named {
name: string;
}
class User implements Named {
name = "Nicolás";
role = "admin";
}La instancia sigue teniendo role; implements solo comprueba el mínimo requerido.
interface Cacheable {
cacheKey?(): string;
}La clase no recibe cacheKey automáticamente ni puede usarlo sin declararlo.
class ProductService
implements Initializable, Disposable {
initialize(): void {}
dispose(): void {}
}Puede ser útil cuando los contratos representan capacidades pequeñas.
interface Serializable {
serialize(): string;
}implements comprueba instancias. No verifica miembros static ni la firma del constructor.
Para el lado estático:
type SerializableConstructor = {
new (...args: any[]): Serializable;
fromJSON(value: string): Serializable;
};La clase se comprueba como valor:
const Constructor: SerializableConstructor = Product;abstract class Entity {
constructor(readonly id: string) {}
abstract validate(): void;
describe(): string {
return `Entity ${this.id}`;
}
}No puede instanciarse directamente.
class Product extends Entity {
validate(): void {
if (this.id.length === 0) {
throw new Error("Invalid id");
}
}
}abstract class DocumentModel {
abstract readonly type: string;
abstract get content(): string;
}abstract class BaseService {
protected constructor(
protected readonly logger: Logger,
) {}
}Solo subclases pueden invocarlo como parte de construcción.
Interface:
Abstract class:
abstract class ProductRepository {
abstract save(product: Product): Promise<void>;
}Puede funcionar, pero una interface es más flexible si no existe comportamiento o identidad runtime compartida.
abstract class Importer<T> {
async import(input: string): Promise<T[]> {
const rawItems = this.parse(input);
return rawItems.map((item) => this.validate(item));
}
protected abstract parse(input: string): unknown[];
protected abstract validate(value: unknown): T;
}La base define el flujo y subclases completan pasos.
Este patrón acopla el algoritmo a herencia; composición con funciones también puede ser más simple.
Una clase puede cumplir una interface sin escribir implements.
const repository: ProductRepository = new CustomRepository();implements aporta feedback dentro de la declaración de clase y documenta intención.
interface Clock {
now(): Date;
}
class SystemClock implements Clock {
now(): Date {
return new Date();
}
}Un fake puede ser un objeto literal; no necesita heredar.
¿Por qué no puedes usar value instanceof ProductRepository cuando ProductRepository es una interface?
Porque la interface se elimina al compilar y no existe como constructor o valor durante ejecución.
Herencia, override y composición explica cómo tipar jerarquías sin confundir reutilización con diseño.