Alai

O autor selecionou o Open Internet/Free Speech Fund para receber uma doação como parte do programa Write for DOnations.

Introduction

No Node.js, um módulo é uma coleção de funções e objetos JavaScript que podem ser usados por aplicações externas. Descrever um pedaço de código como um módulo refere-se menos ao que o código é e mais ao que ele faz – qualquer arquivo Node.js ou coleção de arquivos pode ser considerado um módulo se suas funções e dados forem tornados utilizáveis para programas externos.

Porque os módulos fornecem unidades de funcionalidade que podem ser reutilizadas em muitos programas maiores, eles permitem que você crie aplicações acopladas frouxamente que escalam com complexidade, e abrem a porta para você compartilhar seu código com outros desenvolvedores. Ser capaz de escrever módulos que exportam funções e dados úteis permitirá que você contribua para a comunidade mais ampla do Node.js – na verdade, todos os pacotes que você usa no npm foram agrupados e compartilhados como módulos. Isto torna a criação de módulos uma habilidade essencial para um desenvolvedor Node.js.

Neste tutorial, você criará um módulo Node.js que sugere que cor os desenvolvedores web devem usar em seus projetos. Você desenvolverá o módulo armazenando as cores como um array, e fornecendo uma função para recuperar um aleatoriamente. Em seguida, você irá executar várias maneiras de importar um módulo para uma aplicação Node.js.

Prerequisites

• Você precisará do Node.js e npm instalados no seu ambiente de desenvolvimento. Este tutorial usa a versão 10.17.0. Para instalar isso em macOS ou Ubuntu 18.04, siga os passos em Como instalar o Node.js e Criar um Ambiente de Desenvolvimento Local em macOS ou a seção Como instalar o Node.js no Ubuntu 18.04 usando um PPA. Ao ter o Node.js instalado você também terá o npm instalado; este tutorial usa a versão 6.11.3.
• Você também deve estar familiarizado com o arquivo package.json, e a experiência com comandos npm também seria útil. Para ganhar esta experiência, siga Como Usar os Módulos Node.js com npm e package.json, particularmente o Passo 1 – Criando um package.json Arquivo.
• Também ajudará a ficar confortável com o Node.js REPL (Read-Evaluate-Print-Loop). Você vai usar isto para testar o seu módulo. Se você precisar de mais informações sobre isto, leia nosso guia de Como Usar o Node.js REPL.

Passo 1 – Criando um Módulo

Este passo irá guiá-lo na criação do seu primeiro módulo Node.js. Seu módulo conterá uma coleção de cores em um array e fornecerá uma função para obter uma ao acaso. Você usará a propriedade Node.js incorporada exports para tornar a função e array disponível para programas externos.

Primeiro, você começará decidindo quais dados sobre cores você irá armazenar em seu módulo. Cada cor será um objeto que contém uma propriedade name que os humanos podem facilmente identificar, e uma propriedade code que é uma string contendo um código de cor HTML. Os códigos de cor HTML são números hexadecimais de seis dígitos que permitem alterar a cor dos elementos em uma página web. Você pode aprender mais sobre códigos de cores HTML lendo este artigo HTML Color Codes and Names.

Você então decidirá quais cores você quer suportar no seu módulo. Seu módulo conterá um array chamado allColors que conterá seis cores. Seu módulo também incluirá uma função chamada getRandomColor() que selecionará aleatoriamente uma cor do seu array e a retornará.

No seu terminal, crie uma nova pasta chamada colors e vá para ela:

 
mkdir colors
 
cd colors
 

Initialize npm para que outros programas possam importar este módulo mais tarde no tutorial:

npm init -y 

Você usou a bandeira -y para pular os prompts habituais para personalizar o seu package.json. Se este fosse um módulo que você desejasse publicar para npm, você responderia a todos estes prompts com dados relevantes, como explicado em Como Usar Módulos Node.js com npm e package.json.

Neste caso, sua saída será:

Output
{ "name": "colors", "version": "1.0.0", "description": "", "main": "index.js", "scripts": { "test": "echo \"Error: no test specified\" && exit 1" }, "keywords": , "author": "", "license": "ISC"}

Agora, abra um editor de texto de linha de comando como nano e crie um novo arquivo para servir como ponto de entrada para o seu módulo:

nano index.js

Seu módulo fará algumas coisas. Primeiro, você vai definir uma classe Color. A sua classe Color será instanciada com o seu nome e código HTML. Adicione as seguintes linhas para criar a classe:

class Color { constructor(name, code) { this.name = name; this.code = code; }}

Agora que você tenha sua estrutura de dados para Color, adicione algumas instâncias em seu módulo. Escreva o seguinte array destacado no seu arquivo:

class Color { constructor(name, code) { this.name = name; this.code = code; }}const allColors = ;

Finalmente, insira uma função que selecione aleatoriamente um item do array allColors que você acabou de criar:

class Color { constructor(name, code) { this.name = name; this.code = code; }}const allColors = ;exports.getRandomColor = () => { return allColors;}exports.allColors = allColors;

A palavra-chave exports faz referência a um objeto global disponível em cada módulo Node.js. Todas as funções e objetos armazenados no objeto exports de um módulo são expostos quando outros módulos Node.js o importam. A função getRandomColor() foi criada diretamente no objeto exports, por exemplo. Você então adicionou uma propriedade allColors ao objeto exports que referencia a constante local allColors array criada anteriormente no script.

Quando outros módulos importarem este módulo, ambos allColors e getRandomColor() estarão expostos e disponíveis para uso.

Guardar e sair do arquivo.

Até agora, você criou um módulo que contém um array de cores e uma função que retorna um aleatoriamente. Você também exportou o array e a função, para que programas externos possam usá-los. No próximo passo, você usará seu módulo em outras aplicações para demonstrar os efeitos de export.

Passo 2 – Testando seu módulo com a REPL

Antes de construir uma aplicação completa, tome um momento para confirmar que seu módulo está funcionando. Neste passo, você usará a REPL para carregar o módulo colors. Enquanto estiver na REPL, você irá chamar a função getRandomColor() para ver se ela se comporta como você espera.

Inicie o Nó.js REPL na mesma pasta do index.js arquivo:

node

Quando a REPL for iniciada, você verá o prompt >. Isto significa que você pode digitar código JavaScript que será imediatamente avaliado. Se você gostaria de ler mais sobre isso, siga nosso guia sobre o uso da REPL.

Primeiro, digite o seguinte:

colors = require('./index');

Neste comando, require() carrega o módulo colors em seu ponto de entrada. Ao pressionar ENTER obterá:

Output
{ getRandomColor: , allColors: }

O REPL mostra-nos o valor de colors, que são todas as funções e objectos importados do ficheiro index.js. Quando você usa a palavra-chave require, Node.js retorna todo o conteúdo dentro do objeto exports de um módulo.

Recordar que você adicionou getRandomColor() e allColors a exports no módulo colors. Por essa razão, você vê ambos na REPL quando eles são importados.

No prompt, teste a função getRandomColor():

colors.getRandomColor();

Você será solicitado com uma cor aleatória:

Output
Color { name: 'groovygray', code: '#D7DBDD' }

Como o índice é aleatório, sua saída pode variar. Agora que você confirmou que o módulo colors está funcionando, saia do Node.js REPL:

.exit

Isso o retornará para sua linha de comando do terminal.

Você acabou de confirmar que seu módulo funciona como esperado usando a REPL. Em seguida, você aplicará estes mesmos conceitos e carregará seu módulo em uma aplicação, como faria em um projeto real.

Passo 3 – Salvando seu Módulo Local como uma Dependência

Apesar de testar seu módulo na REPL, você o importou com um caminho relativo. Isto significa que você usou a localização do arquivo index.js em relação ao diretório de trabalho para obter seu conteúdo. Enquanto isto funciona, normalmente é uma melhor experiência de programação importar módulos pelos seus nomes para que a importação não seja quebrada quando o contexto é alterado. Neste passo, você instalará o módulo colors com o módulo local do npm install recurso.

Configurar um novo módulo Node.js fora da pasta colors. Primeiro, vá para o diretório anterior e crie uma nova pasta:

 
cd ..
 
mkdir really-large-application
 

Agora vá para o seu novo projeto:

cd really-large-application

Como com o módulo colors, inicialize sua pasta com npm:

npm init -y 

O seguinte package.json será gerado:

Output
{ "name": "really-large-application", "version": "1.0.0", "description": "", "main": "index.js", "scripts": { "test": "echo \"Error: no test specified\" && exit 1" }, "keywords": , "author": "", "license": "ISC"}

Agora, instale o seu módulo colors e use a bandeira --save para que seja gravado no seu package.json ficheiro:

npm install --save ../colors

Acabou de instalar o seu módulo colors no novo projecto. Abra o arquivo package.json para ver a nova dependência local:

nano package.json

Você verá que as seguintes linhas em destaque foram adicionadas:

{ "name": "really-large-application", "version": "1.0.0", "description": "", "main": "index.js", "scripts": { "test": "echo \"Error: no test specified\" && exit 1" }, "keywords": , "author": "", "license": "ISC", "dependencies": { "colors": "file:../colors" }}

Exit o arquivo.

O módulo colors foi copiado para o seu diretório node_modules. Verifique se ele está lá com o seguinte comando:

ls node_modules

Isto dará a seguinte saída:

Output
colors

Utilize o seu módulo local instalado neste novo programa. Volte a abrir o seu editor de texto e crie outro ficheiro JavaScript:

nano index.js

O seu programa irá importar primeiro o módulo colors. Ele então escolherá uma cor ao acaso usando a função getRandomColor() fornecida pelo módulo. Finalmente, ele irá imprimir uma mensagem para o console que diz ao usuário qual cor usar.

Entrar o seguinte código em index.js:

const colors = require('colors');const chosenColor = colors.getRandomColor();console.log(`You should use ${chosenColor.name} on your website. It's HTML code is ${chosenColor.code}`);

Salve e saia deste arquivo.

A sua aplicação irá agora dizer ao utilizador uma opção de cor aleatória para um componente de website.

Executar este script com:

node index.js

A sua saída será semelhante a:

Output
You should use leafygreen on your website. It's HTML code is #48C9B0

Tem agora instalado com sucesso o módulo colors e pode geri-lo como qualquer outro pacote npm utilizado no seu projecto. No entanto, se você adicionou mais cores e funções ao seu módulo local colors, você teria que executar npm update em suas aplicações para poder usar as novas opções. No próximo passo, você usará o módulo local colors de outra forma e obterá atualizações automáticas quando o código do módulo mudar.

Passo 4 – Ligando um módulo local

Se o seu módulo local estiver em desenvolvimento pesado, a atualização contínua dos pacotes pode ser entediante. Uma alternativa seria ligar os módulos. Ligar um módulo assegura que quaisquer actualizações ao módulo são imediatamente reflectidas nas aplicações que o utilizam.

Neste passo, você ligará o módulo colors à sua aplicação. Você também modificará o módulo colors e confirmará que suas alterações mais recentes funcionam na aplicação sem ter que reinstalar ou atualizar.

Primeiro, desinstale seu módulo local:

npm un colors

spm links módulos usando links simbólicos (ou symlinks), que são referências que apontam para arquivos ou diretórios em seu computador. A ligação de um módulo é feita em dois passos:

1. Criar um link global para o módulo. npm cria um link simbólico entre o seu directório global node_modules e o directório do seu módulo. O diretório global node_modules é o local onde todos os pacotes npm do seu sistema estão instalados (qualquer pacote que você instalar com a bandeira -g).
2. Criar um link local. npm cria um link simbólico entre o seu projeto local que está usando o módulo e o link global do módulo.

Primeiro, crie o link global retornando para a pasta colors e usando o comando link:

 
cd ../colors
 
sudo npm link
 

Após completar, sua shell irá sair:

Output
/usr/local/lib/node_modules/colors -> /home/sammy/colors

Você acabou de criar um link simbólico na sua pasta node_modules para o seu diretório colors.

Volte para a pasta really-large-application e ligue o pacote:

 
cd ../really-large-application
 
sudo npm link colors
 

Receberá uma saída semelhante à seguinte:

Output
/home/sammy/really-large-application/node_modules/colors -> /usr/local/lib/node_modules/colors -> /home/sammy/colors

Nota: Se quiser digitar um pouco menos, pode usar ln em vez de link. Por exemplo, npm ln colors teria funcionado exactamente da mesma forma.

Como a saída mostra, você acabou de criar um link simbólico a partir do seu directório really-large-application local node_modules para o directório colors symlink no seu global node_modules, que aponta para o directório actual com o módulo colors.

O processo de ligação está completo. Execute seu arquivo para garantir que ele ainda funcione:

node index.js

Sua saída será similar a:

Output
You should use sunkissedyellow on your website. It's HTML code is #F4D03F

Sua funcionalidade de programa está intacta. A seguir, teste se as atualizações são aplicadas imediatamente. Em seu editor de texto, reabra o arquivo index.js no módulo colors:

 
cd ../colors
 
nano index.js
 

Agora adicione uma função que selecione a melhor tonalidade de azul que existe. Não leva argumentos, e sempre retorna o terceiro item do array allColors. Adicione estas linhas ao final do arquivo:

class Color { constructor(name, code) { this.name = name; this.code = code; }}const allColors = ;exports.getRandomColor = () => { return allColors; }exports.allColors = allColors;exports.getBlue = () => { return allColors;}

Salve e saia do arquivo, depois reabra o arquivo index.js na pasta really-large-application:

 
cd ../really-large-application
 
nano index.js
 

Faça uma chamada para a função getBlue() recentemente criada, e imprima uma frase com as propriedades da cor. Adicione estas instruções ao final do arquivo:

const colors = require('colors');const chosenColor = colors.getRandomColor();console.log(`You should use ${chosenColor.name} on your website. It's HTML code is ${chosenColor.code}`);const favoriteColor = colors.getBlue();console.log(`My favorite color is ${favoriteColor.name}/${favoriteColor.code}, btw`);

Salve e saia do arquivo.

O código agora usa a função recém-criada getBlue(). Execute o arquivo como antes:

node index.js

Você terá saída como:

Output
You should use brightred on your website. It's HTML code is #E74C3CMy favorite color is skyblue/#5DADE2, btw

Seu script foi capaz de usar a última função no seu módulo colors, sem ter que executar npm update. Isto tornará mais fácil fazer alterações nesta aplicação em desenvolvimento.

Como você escreve aplicações maiores e mais complexas, pense em como o código relacionado pode ser agrupado em módulos, e como você quer que estes módulos sejam configurados. Se o seu módulo só vai ser usado por um programa, ele pode ficar dentro do mesmo projeto e ser referenciado por um caminho relativo. Se o seu módulo será mais tarde partilhado separadamente ou existir num local muito diferente do projecto em que está a trabalhar agora, a instalação ou ligação pode ser mais viável. Os módulos em desenvolvimento ativo também se beneficiam das atualizações automáticas do link. Se o módulo não estiver em desenvolvimento ativo, usar npm install pode ser a opção mais fácil.

Conclusion

Neste tutorial, você aprendeu que um módulo Node.js é um arquivo JavaScript com funções e objetos que podem ser usados por outros programas. Você então criou um módulo e anexou suas funções e objetos ao objeto global exports para torná-los disponíveis a programas externos. Finalmente, você importou esse módulo para um programa, demonstrando como os módulos se juntam em aplicações maiores.

Agora você sabe como criar módulos, pense no tipo de programa que você quer escrever e dividi-lo em vários componentes, mantendo cada conjunto único de atividades e dados em seus próprios módulos. Quanto mais prática você conseguir escrever módulos, melhor será a sua capacidade de escrever programas Node.js de qualidade na sua jornada de aprendizagem. Para trabalhar através de um exemplo de uma aplicação Node.js que utiliza módulos, veja nosso tutorial Como configurar uma aplicação Node.js para produção no Ubuntu 18.04 tutorial.