Namespaces

Namespaces são uma forma de organizar e agrupar código no TypeScript, especialmente útil para evitar conflitos de nomes em projetos maiores. Eles permitem encapsular classes, interfaces, funções e variáveis em um espaço de nomes específico, tornando o código mais modular e gerenciável.

Definindo Namespaces

Para definir um namespace, você usa a palavra-chave namespace seguida pelo nome do namespace e um bloco de código que contém os membros do namespace.

namespace Geometry {
  export class Circle {
    constructor(public radius: number) {}

    area(): number {
      return Math.PI * this.radius * this.radius;
    }
  }

  export class Rectangle {
    constructor(public width: number, public height: number) {}

    area(): number {
      return this.width * this.height;
    }
  }
}

Neste exemplo, definimos um namespace chamado Geometry que contém duas classes: Circle e Rectangle. Note que usamos a palavra-chave export para tornar essas classes acessíveis fora do namespace.

Usando Namespaces

Para usar membros de um namespace, você precisa referenciá-los com o nome do namespace seguido por um ponto e o nome do membro.

const circle = new Geometry.Circle(5);
console.log(circle.area()); // Saída: 78.53981633974483

const rectangle = new Geometry.Rectangle(10, 5);
console.log(rectangle.area()); // Saída: 50

Aqui, estamos criando instâncias das classes Circle e Rectangle dentro do namespace Geometry e chamando seus métodos area.

Namespaces Aninhados

Você pode aninhar namespaces dentro de outros namespaces para uma organização ainda melhor do código.

namespace Geometry {
  export namespace ThreeD {
    export class Cube {
      constructor(public sideLength: number) {}

      volume(): number {
        return this.sideLength ** 3;
      }
    }
  }
}

const cube = new Geometry.ThreeD.Cube(3);
console.log(cube.volume()); // Saída: 27

Neste exemplo, criamos um namespace aninhado ThreeD dentro do namespace Geometry, que contém a classe Cube.

Dividindo Namespaces em Múltiplos Arquivos

Para projetos maiores, você pode querer dividir um namespace em vários arquivos. Use a mesma definição de namespace em cada arquivo e certifique-se de que eles sejam combinados corretamente durante a compilação.

arquivo1.ts:

namespace Geometry {
  export class Circle {
    constructor(public radius: number) {}

    area(): number {
      return Math.PI * this.radius * this.radius;
    }
  }
}

arquivo2.ts:

namespace Geometry {
  export class Rectangle {
    constructor(public width: number, public height: number) {}

    area(): number {
      return this.width * this.height;
    }
  }
}

Para compilar esses arquivos e combiná-los em um único arquivo de saída, você pode usar a opção outFile no tsconfig.json.

tsconfig.json:

{
  "compilerOptions": {
    "outFile": "./dist/bundle.js"
  },
  "include": ["arquivo1.ts", "arquivo2.ts"]
}

Execute o comando tsc para compilar os arquivos e gerar o arquivo bundle.js.

Considerações e Melhores Práticas

• Modularidade: Use namespaces para modularizar seu código e evitar conflitos de nomes, especialmente em projetos grandes.
• Exports: Sempre use a palavra-chave export para tornar membros do namespace acessíveis fora do namespace.
• Organização: Aninhar namespaces pode ajudar a organizar melhor seu código, mas use com moderação para evitar complexidade excessiva.
• Alternativas: Em projetos modernos, considere o uso de módulos ES6, que são uma alternativa mais poderosa e amplamente adotada para organizar e modularizar código.

Namespaces são uma ferramenta poderosa no TypeScript para organizar seu código, mas é importante usá-los de maneira equilibrada para manter o código limpo e gerenciável.