Módulos no TypeScript
Este artigo explica os módulos no TypeScript.
YouTube Video
Módulos no TypeScript
Os módulos no TypeScript são um recurso importante para melhorar a reutilização e manutenção do código. Assim como o JavaScript, o TypeScript também é baseado no sistema de módulos ECMAScript 2015 (ES6), mas uma funcionalidade chave é a capacidade de aproveitar o sistema de tipos do TypeScript.
O que são Módulos?
Um módulo é um sistema para agrupar códigos relacionados em uma única unidade que pode ser importada e reutilizada em outros arquivos. No TypeScript, um escopo é criado por arquivo para encapsular o código, impedindo que ele afete outros arquivos. Isso ajuda a evitar colisões de código e torna a manutenção mais fácil.
Módulos Internos e Externos
- Módulos Internos (Namespaces): Um método de definição de módulo usado no TypeScript 1.5 e anterior, agora não recomendado. Agora é tratado como um 'namespace'.
- Módulos Externos: O padrão atual, baseado no sistema de módulos ES6. Esta seção explica principalmente os módulos externos.
Como Exportar Módulos
Ao criar módulos, a exportação é necessária para permitir o acesso de fora. No TypeScript, você pode exportar valores, funções, classes, etc., usando a palavra-chave export. Existem principalmente dois tipos de exportação.
Exportações Nomeadas
Usado para realizar várias exportações, permitindo que o lado da importação selecione e use itens específicos.
1// mathUtils.ts
2export const pi: number = 3.14159;
3
4export function add(x: number, y: number): number {
5 return x + y;
6}
7
8export function subtract(x: number, y: number): number {
9 return x - y;
10}Exportações Padrão
Usado quando você deseja que o módulo inteiro tenha uma única exportação padrão. Exportações padrão são exportadas sem um nome, permitindo que o lado da importação as receba com qualquer nome.
1// calculator.ts
2export default class Calculator {
3 add(x: number, y: number): number {
4 return x + y;
5 }
6
7 subtract(x: number, y: number): number {
8 return x - y;
9 }
10}Como Importar Módulos
Para usar módulos, você importa valores, funções, classes, etc. de dentro do módulo usando a palavra-chave import.
Importações Nomeadas
Ao importar elementos específicos de uma exportação nomeada, use chaves {}.
1// main.ts
2import { pi, add, subtract } from './mathUtils';
3
4console.log(`Value of pi: ${pi}`);
5console.log(`Addition: ${add(10, 5)}`);
6console.log(`Subtraction: ${subtract(10, 5)}`);Importações Padrão
Ao importar uma exportação padrão, você pode recebê-la com qualquer nome.
1// main.ts
2import Calculator from './calculator';
3
4const calculator = new Calculator();
5console.log(`Addition: ${calculator.add(10, 5)}`);
6console.log(`Subtraction: ${calculator.subtract(10, 5)}`);Apelidos de Importação
Para evitar colisões de nomes ou encurtar nomes longos, você pode importar com um apelido.
1// main.ts
2import { add as addition, subtract as subtraction } from './mathUtils';
3
4console.log(`Addition: ${addition(10, 5)}`);
5console.log(`Subtraction: ${subtraction(10, 5)}`);Diferença Entre Módulos e Namespaces
Um namespace (namespace) é uma estrutura de módulo interna usada nas primeiras versões do TypeScript para agrupar código. Entretanto, os módulos ES6 são agora recomendados, e namespaces raramente são necessários.
Namespaces podem ser definidos dentro do mesmo arquivo ou em vários arquivos, e como podem ser expandidos globalmente, gerenciar dependências pode se tornar difícil. Em contraste, módulos têm escopos separados por arquivo e possuem dependências claras, tornando-os um método mais moderno e seguro.
1// Example of a namespace
2namespace Geometry {
3 export function calculateArea(radius: number): number {
4 return Math.PI * radius * radius;
5 }
6}
7
8// Can be used directly without importing the module (not recommended)
9const area: number = Geometry.calculateArea(5);
10console.log(`Area: ${area}`);Resolução de Módulos no TypeScript
No TypeScript, existem duas estratégias para resolução de módulos.
- Resolução de Módulos Node: O método padrão de resolução usado em ambientes Node.js que resolve módulos pesquisando na pasta
node_modules. - Resolução de Módulos Clássica: O método de resolução próprio do TypeScript que realiza uma busca mais flexível, mas não é comumente usado hoje em dia.
Normalmente, a resolução de módulos Node é usada e está habilitada por padrão, a menos que especificado de outra forma no arquivo de configuração.
Exemplo Prático
Por fim, é apresentado um exemplo de implementação e reutilização de funções computacionais usando módulos.
mathUtils.ts
1export const pi: number = 3.14159;
2
3export function multiply(x: number, y: number): number {
4 return x * y;
5}
6
7export function divide(x: number, y: number): number {
8 if (y === 0) {
9 throw new Error("Cannot divide by zero");
10 }
11 return x / y;
12}calculator.ts
1import { multiply, divide } from './mathUtils';
2
3export default class Calculator {
4 multiplyNumbers(x: number, y: number): number {
5 return multiply(x, y);
6 }
7
8 divideNumbers(x: number, y: number): number {
9 return divide(x, y);
10 }
11}main.ts
1import Calculator from './calculator';
2
3const calculator = new Calculator();
4
5const result1: number = calculator.multiplyNumbers(10, 5);
6console.log(`Multiplication: ${result1}`);
7
8const result2: number = calculator.divideNumbers(10, 2);
9console.log(`Division: ${result2}`);Resumo
O sistema de módulos do TypeScript é uma ferramenta poderosa para organizar código, melhorar a reutilização e aumentar a manutenibilidade. Recomenda-se o uso de módulos externos baseados em módulos ES6, e usar as palavras-chave export e import permite a exportação e importação fácil de módulos.
Você pode acompanhar o artigo acima usando o Visual Studio Code em nosso canal do YouTube. Por favor, confira também o canal do YouTube.