Namespaces e Módulos em TypeScript

Namespaces e módulos são dois conceitos em TypeScript que ajudam a organizar e modularizar seu código. Embora ambos tenham propósitos semelhantes, eles têm características e casos de uso distintos.

Namespaces

Namespaces, anteriormente conhecidos como "módulos internos", são um meio de agrupar uma coleção relacionada de detalhes sob um único nome.

Como estruturar seu código com Namespaces:

namespace MeuNamespace {
    export class MinhaClasse {
        // Implementação da classe
    }

    export interface MinhaInterface {
        // Definição da interface
    }
}

Para usar elementos dentro do namespace, você precisa prefixar com o nome do namespace:

const minhaInstancia = new MeuNamespace.MinhaClasse();

Namespaces aninhados

Namespaces podem ser aninhados para uma organização ainda mais detalhada:

namespace MeuNamespace {
    export namespace SubNamespace {
        export class MinhaSubClasse {
            // Implementação da classe
        }
    }
}

Módulos

Ao contrário dos namespaces, os módulos em TypeScript correspondem mais estreitamente ao módulo ES6 em JavaScript. Eles não adicionam qualquer valor ao escopo global e são mais adaptáveis às técnicas modernas de empacotamento e carregamento de módulos, como CommonJS e AMD.

Como estruturar seu código com Módulos:

Num arquivo meuModulo.ts:

export class MinhaClasse {
    // Implementação da classe
}

export interface MinhaInterface {
    // Definição da interface
}

Para usar elementos de um módulo, você importa eles:

import { MinhaClasse, MinhaInterface } from './meuModulo';

Importação e Exportação de Módulos Avançados:

Exportando como alias

class ClasseInterna {
    // Implementação
}

export { ClasseInterna as MinhaClasseExportada };

Importação com alias

Se houver conflitos de nome ou se o nome for muito longo, você pode usar um alias:

import { MinhaClasseExportada as AliasDeClasse } from './meuModulo';

Importando tudo

import * as TodoMeuModulo from './meuModulo';

const minhaInstancia = new TodoMeuModulo.MinhaClasse();

Exportações padrão

Cada módulo pode ter no máximo uma exportação padrão:

export default class MinhaClassePadrao {
    // Implementação
}

Importando uma exportação padrão:

import MinhaClasse from './meuModulo';

Conclusão

Enquanto namespaces são ótimos para organizar código interno em grandes bases de código TypeScript, módulos são mais alinhados com o ecossistema moderno JavaScript e se adaptam bem com sistemas de carregamento e empacotamento de módulos. Com a crescente adoção de ES6+ e ferramentas como Webpack e Rollup, usar módulos tornou-se a prática padrão recomendada.