Patrones de diseño de TypeScript
Los patrones de diseño son soluciones probadas en el desarrollo de software que nos ayudan a escribir código mantenible y extensible.
El sistema de tipos de TypeScript permite que muchos patrones de diseño clásicos se implementen de forma type-safe (segura en cuanto a tipos).
Diagrama SVG: Clasificación de los patrones de diseño
¿Por qué necesitamos patrones de diseño?
Los patrones de diseño son experiencias de organización de código resumidas por predecesores que pueden resolver problemas comunes de diseño de software.
El uso de patrones de diseño hace que el código sea más fácil de entender y mantener, y también facilita la colaboración en equipo.
El sistema de tipos de TypeScript hace que estos patrones sean más robustos; los errores pueden detectarse en tiempo de compilación.
Concepto:Los patrones de diseño son soluciones reutilizables para problemas comunes en el diseño de software y son un resumen de la experiencia en el diseño de código.
Patrón Singleton (Singleton)
Garantiza que una clase tenga una única instancia y proporciona un punto de acceso global.
Ejemplo
class Singleton {
// Almacena la instancia Singleton
private static instance: Singleton;
private static _data: string = "";
// Constructor privado, evita la instanciación externa
private constructor() {}
// Método estático para obtener la instancia Singleton
public static getInstance(): Singleton {
if (!Singleton.instance) {
Singleton.instance = new Singleton();
}
return Singleton.instance;
}
// Establecer datos
public setData(data: string): void {
Singleton._data = data;
}
// Obtener datos
public getData(): string {
return Singleton._data;
}
}
// Probar el patrón Singleton
const instance1 = Singleton.getInstance();
const instance2 = Singleton.getInstance();
// Verificar que es la misma instancia
console.log("Es la misma instancia: " + (instance1 === instance2));
instance1.setData("Hello Singleton");
console.log("Datos: " + instance2.getData());
Resultado de la ejecución:
是同一实例: true 数据: Hello Singleton
Constructor privado:Al establecer el constructor como private, se evita que el exterior use new para crear instancias.
Patrón de fábrica (Factory)
Usar una fábrica genérica para crear instancias de objetos type-safe.
Ejemplo
interface Product {
name: string;
price: number;
getDescription(): string;
}
// Producto concreto: producto electrónico
class ElectronicProduct implements Product {
constructor(
public name: string,
public price: number,
public warranty: number
) {}
getDescription(): string {
return `${this.name} - ¥${this.price} (Garantía${this.warranty}año)`;
}
}
// Producto concreto: ropa
class ClothingProduct implements Product {
constructor(
public name: string,
public price: number,
public size: string
) {}
getDescription(): string {
return `${this.name} - ¥${this.price} (Talla: ${this.size})`;
}
}
// Clase de fábrica
class ProductFactory {
// Método de fábrica genérico
static create<T extends Product>(
type: new (...args: any[]) => T,
...args: any[]
): T {
return new type(...args);
}
}
// Usar la fábrica para crear productos
const laptop = ProductFactory.create(ElectronicProduct, "Portátil", 5999, 2);
const shirt = ProductFactory.create(ClothingProduct, "Camiseta", 199, "L");
console.log(laptop.getDescription());
console.log(shirt.getDescription());
Fábrica genérica:Usa restricciones genéricas para garantizar que se devuelva el tipo de producto específico.
Patrón decorador (Decorator)
Usa decoradores para añadir funcionalidad a los objetos dinámicamente.
Ejemplo
interface Coffee {
getCost(): number;
getDescription(): string;
}
// Implementación base de café
class SimpleCoffee implements Coffee {
getCost(): number {
return 10;
}
getDescription(): string {
return "Café";
}
}
// Clase base del decorador
abstract class CoffeeDecorator implements Coffee {
constructor(protected coffee: Coffee) {}
getCost(): number {
return this.coffee.getCost();
}
getDescription(): string {
return this.coffee.getDescription();
}
}
// Decorador de leche
class MilkDecorator extends CoffeeDecorator {
getCost(): number {
return this.coffee.getCost() + 2;
}
getDescription(): string {
return this.coffee.getDescription() + ", leche";
}
}
// Decorador de azúcar
class SugarDecorator extends CoffeeDecorator {
getCost(): number {
return this.coffee.getCost() + 1;
}
getDescription(): string {
return this.coffee.getDescription() + ", azúcar";
}
}
// Usar el decorador
let coffee: Coffee = new SimpleCoffee();
console.log(coffee.getDescription() + " - ¥" + coffee.getCost());
coffee = new MilkDecorator(coffee);
console.log(coffee.getDescription() + " - ¥" + coffee.getCost());
coffee = new SugarDecorator(coffee);
console.log(coffee.getDescription() + " - ¥" + coffee.getCost());
Decorador:Puede añadir dinámicamente nuevas funcionalidades sin modificar la clase original; es una característica experimental de TypeScript.
Patrón observador (Observer)
Define una relación de dependencia de uno a muchos entre objetos; cuando el estado del objeto cambia, todos los dependientes reciben una notificación.
Ejemplo
interface Observer {
update(message: string): void;
}
// Interfaz del tema (subject)
interface Subject {
attach(observer: Observer): void;
detach(observer: Observer): void;
notify(): void;
}
// Tema concreto: centro de mensajes
class MessageCenter implements Subject {
private observers: Observer[] = [];
private message: string = "";
// Añadir observador
attach(observer: Observer): void {
this.observers.push(observer);
}
// Eliminar observador
detach(observer: Observer): void {
const index = this.observers.indexOf(observer);
if (index > -1) {
this.observers.splice(index, 1);
}
}
// Notificar a todos los observadores
notify(): void {
for (const observer of this.observers) {
observer.update(this.message);
}
}
// Publicar mensaje
publish(message: string): void {
this.message = message;
console.log("Publicar mensaje: " + message);
this.notify();
}
}
// Observador concreto: usuario
class UserObserver implements Observer {
constructor(public name: string) {}
update(message: string): void {
console.log(`[${this.name}]Recibir mensaje: ${message}`);
}
}
// Usar el patrón observador
const center = new MessageCenter();
const user1 = new UserObserver("Usuario A");
const user2 = new UserObserver("Usuario B");
center.attach(user1);
center.attach(user2);
center.publish("¡Nueva función disponible!");
Desacoplamiento:El patrón observador logra un acoplamiento débil entre el tema y los observadores.
Patrón de estrategia (Strategy)
Define una familia de algoritmos, los encapsula uno a uno y permite que sean intercambiables.
Ejemplo
interface PaymentStrategy {
pay(amount: number): void;
}
// Estrategia de pago con WeChat
class WechatPayStrategy implements PaymentStrategy {
pay(amount: number): void {
console.log(`Pagar con WeChat ¥${amount}`);
}
}
// Estrategia de Alipay
class AlipayStrategy implements PaymentStrategy {
pay(amount: number): void {
console.log(`Pagar con Alipay ¥${amount}`);
}
}
// Estrategia de tarjeta bancaria
class CardPayStrategy implements PaymentStrategy {
pay(amount: number): void {
console.log(`Pagar con tarjeta bancaria ¥${amount}`);
}
}
// Contexto de pago
class PaymentContext {
private strategy: PaymentStrategy;
constructor(strategy: PaymentStrategy) {
this.strategy = strategy;
}
// Establecer la estrategia de pago
setStrategy(strategy: PaymentStrategy): void {
this.strategy = strategy;
}
// Ejecutar el pago
pay(amount: number): void {
this.strategy.pay(amount);
}
}
// Usar el patrón de estrategia
const context = new PaymentContext(new WechatPayStrategy());
context.pay(100);
context.setStrategy(new AlipayStrategy());
context.pay(200);
context.setStrategy(new CardPayStrategy());
context.pay(300);
Cambio de algoritmo:El patrón de estrategia permite cambiar el algoritmo en tiempo de ejecución, lo que ofrece una gran flexibilidad.
Inyección de dependencias (Dependency Injection)
Inyecta dependencias a través del constructor; es uno de los patrones más utilizados en TypeScript.
Ejemplo
interface Logger {
log(message: string): void;
}
interface Storage {
save(key: string, data: any): void;
}
// Implementación concreta del servicio
class ConsoleLogger implements Logger {
log(message: string): void {
console.log("[Log]: " + message);
}
}
class LocalStorage implements Storage {
save(key: string, data: any): void {
console.log(`Guardar ${key}: ${JSON.stringify(data)}`);
localStorage.setItem(key, JSON.stringify(data));
}
}
// Servicio que usa inyección de dependencias
class UserService {
constructor(
private logger: Logger,
private storage: Storage
) {}
createUser(name: string): void {
const user = { name, createdAt: new Date() };
this.logger.log("Crear usuario: " + name);
this.storage.save("user", user);
}
}
// Inyectar dependencias
const logger = new ConsoleLogger();
const storage = new LocalStorage();
const userService = new UserService(logger, storage);
userService.createUser("Alice");
Inversión de dependencias:La inyección de dependencias logra que los módulos de alto nivel no dependan de los módulos de bajo nivel, sino de interfaces abstractas.
Patrón constructor (Builder)
Separa la construcción de un objeto complejo de su representación, de modo que el mismo proceso de construcción pueda crear diferentes representaciones.
Ejemplo
interface Builder<T> {
build(): T;
}
// Objeto complejo: configuración de usuario
interface UserConfig {
name: string;
email: string;
age?: number;
role?: string;
theme?: string;
}
// Constructor de configuración de usuario
class UserConfigBuilder implements Builder<UserConfig> {
private config: Partial<UserConfig> = {};
setName(name: string): this {
this.config.name = name;
return this;
}
setEmail(email: string): this {
this.config.email = email;
return this;
}
setAge(age: number): this {
this.config.age = age;
return this;
}
setRole(role: string): this {
this.config.role = role;
return this;
}
setTheme(theme: string): this {
this.config.theme = theme;
return this;
}
build(): UserConfig {
if (!this.config.name || !this.config.email) {
throw new Error("Name and email are required");
}
return this.config as UserConfig;
}
}
// Usar el constructor
const builder = new UserConfigBuilder();
const config = builder
.setName("Alice")
.setEmail("alice@example.com")
.setAge(25)
.setRole("admin")
.setTheme("dark")
.build();
console.log("Configuración de usuario:", JSON.stringify(config, null, 2));
Llamadas encadenadas:El patrón constructor admite llamadas encadenadas, lo que hace que el código sea más conciso y legible.
Consideraciones
- Seguridad de tipos:Aprovechar el sistema de tipos de TypeScript para garantizar la seguridad de la implementación de los patrones
- No abuses:Usa patrones de diseño solo cuando realmente sea necesario
- Mantén la simplicidad:Prioriza soluciones simples
- Consenso del equipo:Unificar el uso de patrones de diseño dentro del equipo
Buenas prácticas:Los patrones de diseño son herramientas, no dogmas. Elige el patrón que se adapte a la situación real del proyecto.
Resumen
Los patrones de diseño son una experiencia importante en la organización del código.
- Patrón Singleton:Garantiza que la clase tenga una única instancia
- Patrón de fábrica:Encapsula el proceso de creación de objetos
- Patrón decorador:Añade funcionalidad dinámicamente
- Patrón observador:Relación de dependencia de uno a muchos
- Patrón de estrategia:Algoritmos intercambiables
- Inyección de dependencias:Desacopla las dependencias
Otras extensionesConsejo:Comprender y aplicar los patrones de diseño en la práctica permite escribir código más elegante y fácil de mantener.