Base de Conhecimento

Introdução

No Node.js, um módulo é uma coleção de funções e objetos JavaScript que podem ser usados ​​por aplicativos externos. A descrição de um pedaço de código como módulo refere-se menos ao que é o código e mais ao que ele faz - qualquer arquivo ou coleção de arquivos do Node.js. pode ser considerado um módulo se suas funções e dados forem utilizados em programas externos.

Como os módulos fornecem unidades de funcionalidade que podem ser reutilizadas em muitos programas maiores, eles permitem que você crie aplicativos pouco acoplados que escalam com a 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 Node.js mais ampla - na verdade, todos os pacotes que você usa no npm foram empacotados e compartilhados como módulos. Isso torna a criação de módulos uma habilidade essencial para um desenvolvedor do Node.js.

Neste tutorial, você criará um módulo Node.js. que sugere que cores os desenvolvedores da Web devem usar em seus designs. Você desenvolverá o módulo armazenando as cores como uma matriz e fornecendo uma função para recuperar uma aleatoriamente. Posteriormente, você executará várias maneiras de importar um módulo para um aplicativo Node.js.

Pré-requisitos

• Você precisará do Node.js e do npm instalados no seu ambiente de desenvolvimento. Este tutorial usa a versão 10.17.0. Para instalar isso no macOS ou no Ubuntu 18.04, siga as etapas em Como instalar o Node.js e criar um ambiente de desenvolvimento local no macOS ou na seção Instalando usando um PPA de Como instalar o Node.js. no Ubuntu 18.04 . 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 package.jsonarquivo, e a experiência com os comandos npm também seria útil. Para obter essa experiência, siga Como usar os módulos Node.js. com npm e package.json , particularmente a Etapa 1 - Criando um package.jsonarquivo .
• Também ajudará a se sentir confortável com o NPL.js REPL (Ler-Avaliar-Imprimir-Loop). Você usará isso para testar seu módulo. Se precisar de mais informações sobre isso, leia nosso guia sobre como usar o Node.js REPL .

Etapa 1 - Criando um módulo

Esta etapa o guiará na criação do seu primeiro módulo Node.js. Seu módulo conterá uma coleção de cores em uma matriz e fornecerá uma função para obter uma aleatoriamente. Você usará a propriedade interna Node.js. exportspara disponibilizar a função e a matriz para programas externos.

Primeiro, você começará decidindo quais dados sobre cores você armazenará em seu módulo. Toda cor será um objeto que contém uma namepropriedade que os humanos podem identificar facilmente e uma codepropriedade que é uma sequência que contém um código de cores HTML. Os códigos de cores HTML são números hexadecimais de seis dígitos que permitem alterar a cor dos elementos em uma página da web. Você pode aprender mais sobre códigos de cores HTML lendo este artigo Nomes e códigos de cores HTML .

Você então decide quais cores deseja apoiar no seu módulo. Seu módulo conterá uma matriz chamada allColorsque conterá seis cores. Seu módulo também incluirá uma função chamada getRandomColor()que selecionará aleatoriamente uma cor da sua matriz e a retornará.

No seu terminal, crie uma nova pasta chamada colorse entre nela:

• mkdir colors
• cd colors

Inicialize o npm para que outros programas possam importar este módulo posteriormente no tutorial:

• npm init -y

Você usou a -ybandeira para pular as solicitações usuais para personalizar sua package.json. Se esse fosse um módulo que você desejasse publicar no npm, você responderia a todas essas solicitações com dados relevantes, conforme explicado em Como usar os módulos do Node.js. com o npm e o package.json .

Nesse caso, sua saída será:

{
  "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 nanoe 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ê definirá uma Color classe . Sua Colorclasse será instanciada com 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ê possui sua estrutura de dados Color, adicione algumas instâncias ao seu módulo. Escreva a seguinte matriz destacada no seu arquivo:

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

const allColors = [
  new Color('brightred', '#E74C3C'),
  new Color('soothingpurple', '#9B59B6'),
  new Color('skyblue', '#5DADE2'),
  new Color('leafygreen', '#48C9B0'),
  new Color('sunkissedyellow', '#F4D03F'),
  new Color('groovygray', '#D7DBDD'),
];

Por fim, insira uma função que selecione aleatoriamente um item da allColorsmatriz que você acabou de criar:

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

const allColors = [
  new Color('brightred', '#E74C3C'),
  new Color('soothingpurple', '#9B59B6'),
  new Color('skyblue', '#5DADE2'),
  new Color('leafygreen', '#48C9B0'),
  new Color('sunkissedyellow', '#F4D03F'),
  new Color('groovygray', '#D7DBDD'),
];

exports.getRandomColor = () => {
  return allColors[Math.floor(Math.random() * allColors.length)];
}

exports.allColors = allColors;

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

Quando outros módulos importar este módulo, tanto allColorse getRandomColor()serão expostos e disponíveis para uso.

Salve e saia do arquivo.

Até agora, você criou um módulo que contém uma matriz de cores e uma função que retorna uma aleatoriamente. Você também exportou a matriz e a função, para que programas externos possam usá-los. Na próxima etapa, você usará seu módulo em outros aplicativos para demonstrar os efeitos do export.

Etapa 2 - Testando seu módulo com o REPL

Antes de criar um aplicativo completo, reserve um momento para confirmar que seu módulo está funcionando. Nesta etapa, você usará o REPL para carregar o colorsmódulo. Enquanto estiver no REPL, você chamará a getRandomColor()função para ver se ela se comporta conforme o esperado.

Inicie o Node.js REPL na mesma pasta que o index.jsarquivo:

• node

Quando o REPL for iniciado, você verá o >prompt. Isso significa que você pode inserir o código JavaScript que será imediatamente avaliado. Se você quiser ler mais sobre isso, siga nosso guia sobre o uso do REPL .

Primeiro, digite o seguinte:

• colors = require('./index');

Neste comando, require()carrega o colorsmódulo em seu ponto de entrada. Quando você pressiona, ENTERvocê obtém:

{
  getRandomColor: [Function],
  allColors: [
    Color { name: 'brightred', code: '#E74C3C' },
    Color { name: 'soothingpurple', code: '#9B59B6' },
    Color { name: 'skyblue', code: '#5DADE2' },
    Color { name: 'leafygreen', code: '#48C9B0' },
    Color { name: 'sunkissedyellow', code: '#F4D03F' },
    Color { name: 'groovygray', code: '#D7DBDD' }
  ]
}

O REPL mostra o valor de colors, que são todas as funções e objetos importados do index.jsarquivo. Quando você usa a requirepalavra - chave, Node.js retorna todo o conteúdo no exportsobjeto de um módulo.

Lembre-se que você adicionou getRandomColor()e allColorspara exportsno colorsmódulo. Por esse motivo, você vê os dois no REPL quando são importados.

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

• colors.getRandomColor();

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

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

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

• .exit

Isso retornará você à sua linha de comando do terminal.

Você acabou de confirmar que seu módulo funciona conforme o esperado usando o REPL. Em seguida, você aplicará esses mesmos conceitos e carregará seu módulo em um aplicativo, como faria em um projeto real.

Etapa 3 - Salvando seu módulo local como uma dependência

Ao testar seu módulo no REPL, você o importou com um caminho relativo . Isso significa que você usou o local do index.jsarquivo em relação ao diretório de trabalho para obter seu conteúdo. Enquanto isso funciona, geralmente é uma experiência de programação melhor importar módulos por seus nomes, para que a importação não seja interrompida quando o contexto for alterado. Nesta etapa, você instalará o colorsmódulo com o installrecurso de módulo local do npm .

Configure um novo módulo Node.js fora da colorspasta. 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 no colorsmódulo, inicialize sua pasta com npm:

• npm init -y

O seguinte package.jsonserá gerado:

{
  "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 seu colorsmódulo e use o --savesinalizador para que ele seja gravado em seu package.jsonarquivo:

• npm install --save ../colors

Você acabou de instalar seu colorsmódulo no novo projeto. Abra o package.jsonarquivo para ver a nova dependência local:

• nano package.json

Você verá que as seguintes linhas destacadas 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"
  }
}

Saia do arquivo

O colorsmódulo foi copiado para o seu node_modulesdiretório. Verifique se está lá com o seguinte comando:

• ls node_modules

Isso dará a seguinte saída:

colors

Use o módulo local instalado neste novo programa. Abra novamente o seu editor de texto e crie outro arquivo JavaScript:

• nano index.js

Seu programa importará primeiro o colorsmódulo. Ele escolherá uma cor aleatoriamente usando a getRandomColor()função fornecida pelo módulo. Por fim, imprimirá uma mensagem no console informando ao usuário qual cor usar.

Digite 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.

Seu aplicativo agora informará ao usuário uma opção de cor aleatória para um componente do site.

Execute este script com:

• node index.js

Sua saída será semelhante a:

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

Agora você instalou o colorsmódulo com sucesso e pode gerenciá-lo como qualquer outro pacote npm usado em seu projeto. No entanto, se você adicionou mais cores e funções ao seu colorsmódulo local , seria necessário executar npm updateseus aplicativos para poder usar as novas opções. Na próxima etapa, você usará o módulo local de colorsoutra maneira e obterá atualizações automáticas quando o código do módulo for alterado.

Etapa 4 - Vinculando um módulo local

Se o seu módulo local estiver em desenvolvimento pesado, a atualização contínua de pacotes pode ser entediante. Uma alternativa seria vincular os módulos. A vinculação de um módulo garante que quaisquer atualizações no módulo sejam refletidas imediatamente nos aplicativos que o utilizam.

Nesta etapa, você vinculará o colorsmódulo ao seu aplicativo. Você também modificará o colorsmódulo e confirmará que as alterações mais recentes funcionam no aplicativo sem precisar reinstalar ou atualizar.

Primeiro, desinstale o módulo local:

• npm un colors

Os módulos do npm links usam links simbólicos (ou links simbólicos), que são referências que apontam para arquivos ou diretórios no seu computador. A vinculação de um módulo é feita em duas etapas:

1. Criando um link global para o módulo. O npm cria um link simbólico entre o node_modulesdiretório global e o diretório do seu módulo. O node_modulesdiretório global é o local em que todos os seus pacotes npm em todo o sistema estão instalados (qualquer pacote que você instala com o -gsinalizador).
2. Crie um link local . O npm cria um link simbólico entre o projeto local que está usando o módulo e o link global do módulo.

Primeiro, crie o link global retornando à colorspasta e usando o linkcomando:

• cd ../colors
• sudo npm link

Depois de concluído, seu shell exibirá:

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

Você acabou de criar um link simbólico na sua node_modulespasta para o seu colorsdiretório.

Volte para a really-large-applicationpasta e vincule o pacote:

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

Você receberá uma saída semelhante à seguinte:

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

Nota : Se você deseja digitar um pouco menos, pode usar em lnvez de link. Por exemplo, npm ln colorsteria funcionado exatamente da mesma maneira.

Como mostra a saída, você acabou de criar um link simbólico do diretório really-large-applicationlocal do seu node_modulespara o colorslink simbólico no seu global node_modules, que aponta para o diretório real com o colorsmódulo.

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

• node index.js

Sua saída será semelhante a:

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

A funcionalidade do seu programa está intacta. Em seguida, teste se as atualizações são aplicadas imediatamente. No seu editor de texto, abra novamente o index.jsarquivo no colorsmódulo:

• cd ../colors
• nano index.js

Agora adicione uma função que selecione o melhor tom de azul que existe. Não requer argumentos e sempre retorna o terceiro item da allColorsmatriz. Adicione estas linhas ao final do arquivo:

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

const allColors = [
  new Color('brightred', '#E74C3C'),
  new Color('soothingpurple', '#9B59B6'),
  new Color('skyblue', '#5DADE2'),
  new Color('leafygreen', '#48C9B0'),
  new Color('sunkissedyellow', '#F4D03F'),
  new Color('groovygray', '#D7DBDD'),
];

exports.getRandomColor = () => {
        return allColors[Math.floor(Math.random() * allColors.length)];
        }

exports.allColors = allColors;

exports.getBlue = () => {
  return allColors[2];
}

Salve e saia do arquivo e abra-o novamente index.jsna really-large-applicationpasta:

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

Faça uma chamada para a getBlue()função recém-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 getBlue()função recém-criada . Execute o arquivo como antes:

• node index.js

Você obterá saída como:

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

Seu script foi capaz de usar a função mais recente em seu colorsmódulo, sem precisar executar npm update. Isso tornará mais fácil fazer alterações nesse aplicativo em desenvolvimento.

Ao escrever aplicativos maiores e mais complexos, pense em como o código relacionado pode ser agrupado em módulos e como você deseja que esses módulos sejam configurados. Se o seu módulo for usado apenas por um programa, ele poderá permanecer no mesmo projeto e ser referenciado por um caminho relativo. Se o seu módulo posteriormente for compartilhado separadamente ou existir em um local muito diferente do projeto no qual você está trabalhando agora, a instalação ou vinculação poderá ser mais viável. Módulos em desenvolvimento ativo também se beneficiam das atualizações automáticas de vinculação. Se o módulo não estiver em desenvolvimento ativo, o uso npm installpode ser a opção mais fácil.

Conclusão

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ê criou um módulo e anexou suas funções e objetos ao exportsobjeto global para torná-los disponíveis para programas externos. Por fim, você importou esse módulo para um programa, demonstrando como os módulos se reúnem em aplicativos maiores.