[Design Patterns] Construindo um Singleton em Typescript

Fala pessoal!

A jornada do aprendizado na área de desenvolvimento é realmente longa, para uns traz a sensação de que não está aprendendo, e que precisa decorar todos os códigos. Alguns pensam que a quantidade de informações é exponencial, e tende ao infinito. Eu concordo com a segunda afirmação! hahah Com a ressalva de que vamos estudar a vida inteira, e não vamos estar nem perto de absorver toda essa informação, logicamente.

Um dos conhecimentos mais valiosos que aprendi na universidade, foi estruturar as informações em padrões, e transformar os padrões em soluções lógicas (Design Patterns).

Fora da universidade eu me aventurei como instrutor em uma escola de programação, durante o curso de Ciência da Computação. Foi assim que aprendi a aprender, ensinando sem a pretensão de me tornar professor.

Hoje decidi voltar a escrever sobre desenvolvimento de software, e minha primeira aventura é neste forúm maravilhoso!

Onde eu explico sobre o básico para criarmos um Pattern Singleton em Typescript, e seus objetivos.

Segue!

O padrão Singleton é um dos padrões(Design patterns) mais utilizados, e está presentes na camada criacional, uma das camadas de design definidas pelo livro “Design Patterns: Elements of Reusable Object-Oriented Software” de 1994, escrito por GOF (Gang of Four: Rich Gamma, Richard Helm, Ralph Johnson e John Vlissides). Esse pattern assegura que somente uma instancia de uma determinada classe seja criado em todo o projeto.

Vejam uma implementação simples em Typescript:

class Singleton {
    private static _instance: Singleton | null = null;
    private constructor(){}
    public static get instance(): Singleton {
        if (this._instance === null) {
            this._instance = new Singleton();
        }
        return this._instance;
    }
    anyMethod(): void {
        console.log("anyMethod")
    }
}

const singleton = Singleton.instance.anyMethod()

Uso prático

É muito comum utilizar esse padrão para criarmos classes que vão ser chamadas diversas vezes no projeto. Por exemplo uma conexão com o banco de dados:

class PgConnection {
    private static _instance: PgConnection | null = null;
    private constructor() { }
    public static get instance(): PgConnection {
        if (this._instance === null) {
            this._instance = new PgConnection();
        }
        return this._instance;
    }

    async connect(): Promise<void> {

    }

    async disconnect(): Promise<void> {

    }
}

const connection = PgConnection.instance
connection.connect()
connection.disconnect()

Podemos oberservar que:

O construtor é privado O método _instance() é público e estático Retorna a única instância que é guardada em uma variável de classe

Desta forma, garante que uma classe tenha apenas uma instância e fornece um ponto global de acesso a ela. O benefício principal de se usar esse pattern, é tornar fácil o acesso e gerência de recursos compartilhados, como variáveis globais.

Referência: Design Patterns: Elements of Reusable Object-Oriented Software” de 1994, escrito por GOF (Gang of Four: Rich Gamma, Richard Helm, Ralph Johnson e John Vlissides) https://homepages.dcc.ufmg.br/~figueiredo/disciplinas/aulas/padroes-gof_v01.pdf

Github: https://github.com/mauriciocarvalho01/design-patterns-examples/tree/main/src/creational/singleton