Padrões de Projeto em TypeScript: Singleton vs Factory vs Decorator
Tags: designpatterns, typescript, javascript, programming
Published: 2024-01-08 09:30:02

## Introdução

Padrões de projeto são métodos comprovados para resolver problemas comuns no desenvolvimento de software. TypeScript, com sua tipagem forte e recursos avançados, é uma linguagem poderosa para implementar esses padrões de forma eficaz. Vamos explorar detalhadamente alguns dos padrões de projeto mais utilizados: Singleton, Factory e Decorator.

## 1. Singleton

### Conceito e Contexto
O Singleton é um padrão de criação que tem como objetivo garantir que uma classe tenha apenas uma instância em toda a aplicação, proporcionando um ponto de acesso global a ela. Esse padrão é útil quando precisamos de um controle centralizado e consistente de recursos, como conexões de banco de dados ou configurações de sistema.

### Implementação em TypeScript

```typescript
class Singleton {
    private static instance: Singleton;

    private constructor() {
        // construtor privado impede a instanciação direta
    }

    public static getInstance(): Singleton {
        if (!Singleton.instance) {
            Singleton.instance = new Singleton();
        }
        return Singleton.instance;
    }
}
```

### Discussão
A implementação do Singleton em TypeScript é direta. Usamos um construtor privado para prevenir a criação de instâncias externas e um método estático para gerenciar a instância única. Esse padrão é especialmente útil em TypeScript devido à sua natureza tipada, garantindo que o uso da instância Singleton seja consistente em toda a aplicação.

## 2. Factory

### Conceito e Contexto
O padrão Factory é um padrão de criação que fornece uma interface para criar objetos em uma superclasse, permitindo que as subclasses alterem o tipo dos objetos criados. Esse padrão é frequentemente usado quando um sistema deve ser independente de como seus produtos são criados, compostos e representados.

### Implementação em TypeScript

```typescript
interface Product {
    doStuff(): void;
}

class ConcreteProductA implements Product {
    public doStuff() {
        console.log('Product A stuff');
    }
}

class ConcreteProductB implements Product {
    public doStuff() {
        console.log('Product B stuff');
    }
}

class Factory {
    public static createProduct(type: string): Product {
        switch (type) {
            case 'A': return new ConcreteProductA();
            case 'B': return new ConcreteProductB();
            default: throw new Error('Product type not supported.');
        }
    }
}
```

### Discussão
O padrão Factory em TypeScript é ideal para cenários onde temos várias implementações de uma interface e queremos abstrair a lógica de criação desses objetos. TypeScript adiciona uma camada de segurança, garantindo que os objetos criados sigam a interface definida.

## 3. Decorator

### Conceito e Contexto
Decorator é um padrão de projeto estrutural que permite adicionar novas funcionalidades a objetos dinamicamente, envolvendo-os com novos comportamentos. É uma alternativa flexível à herança para estender a funcionalidade.

### Implementação em TypeScript

```typescript
interface Component {
    operation(): string;
}

class ConcreteComponent implements Component {
    public operation(): string {
        return 'ConcreteComponent';
    }
}

class Decorator implements Component {
    protected component: Component;

    constructor(component: Component) {
        this.component = component;
    }

    public operation(): string {
        return `Decorator(${this.component.operation()})`;
    }
}
```

### Discussão
O padrão Decorator em TypeScript é útil para adicionar responsabilidades a objetos de forma dinâmica e transparente. A tipagem forte do TypeScript garante que o componente decorado e o decorator cumpram a mesma interface, facilitando a interoperabilidade e mantendo a consistência.

## Conclusão

Estes padrões de projeto em TypeScript demonstram a eficácia da linguagem em fornecer soluções robustas e escaláveis para problemas comuns de design de software. Com a tipagem forte e recursos avançados do TypeScript, os desenvolvedores podem implementar esses padrões de maneira eficiente, garantindo código limpo, manutenível e de alta qualidade.