Módulos

Normalmente, o código em node.js está estruturado em módulos. O que são módulos ?
Módulos são ficheiros de javascript que podemos incorporar numa aplicação.

Cada módulo no Node.js possui o seu próprio contexto, portanto, não pode interferir com outros módulos ou poluir o escopo global. Além disso, cada módulo pode ser colocado num ficheiro .js separado numa pasta separada.

Funções e variáveis declaradas num módulo são privadas a esse módulo. Se quisermos aceder a uma variável ou função de um módulo teremos de as exportar.

Para importar um módulo usamos a função require().

Existem 3 tipos de módulos no node.js:

• Módulos internos
• Módulos locais
• Módulos externos

Módulos internos

São módulos que já vêm incluídos no núcleo do node.js bastando importá-los com a função require().
Alguns dos mais usados módulos do núcleo do node.js são os seguintes:

• fs: permite manipular (criar / ler / gravar) ficheiros e diretórios.
• path: utilitários para trabalhar com ficheiros e diretórios.
• http: cria servidores e clientes HTTP para desenvolvimento web.
• url: utilitários para analisar URLs e extrair elementos dele.

Exemplo:

const fs = require('fs'); 

fs.readFile('./file.txt', 'utf-8', (err, data) => { 
if(err) { throw err; } 
   console.log('data: ', data); 
});    

No exemplo acima, importámos o módulo fs e usámos o método readFile().

Módulos locais

Módulos locais são módulos criados localmente na sua aplicação node.js. Esses módulos incluem diferentes funcionalidades da sua aplicação em ficheiros e pastas separados. Podemos também empacotá-lo e distribuí-lo via NPM, para que a comunidade do node.js. possa usá-lo.

Por exemplo, se você precisar se conectar ao MongoDB e buscar dados, poderá criar um módulo para ele, que poderá ser reutilizado na sua aplicação.

Criar um módulo local

Vamos criar um módulo num ficheiro chamado log.js.

var log = {  
   info: function (info) { 
      console.log('Info: ' + info); 
   }, 
   warning:function (warning) { 
      console.log('Warning: ' + warning); 
   }, 
   error:function (error) { 
      console.log('Error: ' + error); 
   } 
};

module.exports = log 

O módulo consiste num objeto log com 3 métodos: info(), warning() e error() que mostram mensagens na consola.

No final exportamos o objeto para que possa ser acedido pela aplicação.

NOTA: como module é um objeto global, podemos usar somente exports porque o node.js assigna-o ao objeto module.

Importar o módulo

Para usar módulos locais numa aplicação, temos de carregá-lo usando a função require() da mesma maneira que nos core modules. No entanto, precisamos especificar o caminho do ficheiro JavaScript do módulo.

O exemplo a seguir demonstra como usar o módulo desenvolvido no ficheiro log.js:

var log = require('./log.js'); 

log.info('Node.js started'); 

No exemplo acima, usamos o módulo log no ficheiro app.js. Primeiro, carregamos o módulo usando a função require() e o caminho do ficheiro onde está o módulo. O módulo de log está contido no ficheiro log.js na raiz. Portanto, especificamos o caminho ‘./log.js’ na função require (). O ‘.’ indica a pasta raiz.

A função require() retorna um objeto de log porque o módulo de log expõe um objeto no log.js. usando module.exports. Portanto, agora você pode usar o módulo de log como um objeto e chamar qualquer um dos seus métodos usando a notação de ponto, por exemplo, log.info() ou log.warning() ou log.error().

Exportar um módulo

Na seção anterior, vimos como escrever um módulo local usando module.exports. Nesta seção, veremos como expor tipos diferentes como um módulo usando module.exports.

O module.exports ou exports é um objeto especial que é incluído em todos os ficheiros JS numa aplicação node.js. Por padrão, module é uma variável que representa o módulo atual e as exportações são um objeto que será exposto como um módulo. Portanto, o que atribuirmos a module.exports ou exportações, será exposto como um módulo.

Vamos ver como expor diferentes tipos como um módulo usando module.exports.

Exportar literais

Como mencionado acima, as exportações são um objeto. Portanto, expõe o que atribuimos a ele como um módulo. Por exemplo, se atribuirmos uma string, ele a exporá como um módulo.

O exemplo a seguir expõe uma mensagem de string como um módulo no ficheiro message.js:

message.js

module.exports = 'Olá mundo'; 
//ou 
exports = 'Olá mundo'; 

Vamos agora importar este módulo e usá-lo no ficheiro app.js:

message.js

var msg = require('./message.js'); 
console.log(msg);

Se executarmos o ficheiro app.js teremos o seguinte output:

C:\> node app.j
Olá mundo

Exportar funções

Podemos anexar uma função anónima ao objeto exports, como mostrado abaixo:

log.js

module.exports = function (msg) { 
   console.log(msg); 
};

Importamos a função no ficheiro app.js:

app.js

var msg = require('./log.js'); 
msg('Hello World'); 

Outra maneira de exportar uma função é atribui-la a um objeto no objeto exports:

math.js

module.exports.add = function (x, y) { 
   return x + y; 
}; 

Importamos módulo math:

var math = require('./math'); 
console.log("Soma: 11 e 4 = " + math.add(11, 4));

Podemos criar um módulo que exporte um objeto com várias funções:

math.js

module.exports = { 
   add: function(x, y){ 
      return x + y; 
   }, 
   sub: function(x, y){ 
      return x - y; 
   }, 
   mul: function(x, y){ 
      return x * y; 
   }, 
   div: function(x, y){ 
      return x / y; 
   } 
} 

Importamos o módulo no ficheiro app.js:

var math = require('./math.js'); 
 
console.log("Soma: 11 e 4 = " + math.add(11, 4)); 

Exortar funções como classes

Em JavaScript, uma função pode ser tratada como uma classe. O exemplo a seguir expõe uma função que pode ser usada como uma classe.

person.js

module.exports = function (firstName, lastName) { 
   this.firstName = firstName; 
   this.lastName = lastName; 
   this.fullName = function () { 
      return this.firstName + ' ' + this.lastName; 
   } 
} 

O módulo acima pode agora ser usado no ficheiro app.js:

app.js

var person = require('./person.js'); 
var person1 = new person('James', 'Bond'); 
console.log(person1.fullName()); 

Output:

C:\> node app.js 
James Bond

O objeto exports

exports é um objeto. Portanto, podemos anexar propriedades ou métodos a ele. O exemplo a seguir expõe um objeto com uma propriedade string no ficheiro message.js.

message.js

exports.SimpleMessage = 'Olá mundo'; 
//ou 
module.exports.SimpleMessage = 'Olá mundo'; 

Importamos o módulo no ficheiro app.js:

app.js

var msg = require('./message.js'); 
console.log(msg.SimpleMessage);

Output:

C:\> node app.js 
Hello World

Da mesma forma, podemos anexar uma função ao objeto exports:

log.js

module.exports.log = function (msg) { 
   console.log(msg); 
}; 

vamos agora usar o módulo no ficheiro app.js:

app.js

var msg = require('./Log.js'); 
msg.log('Hello World');

Output:

C:\> node app.js 
Hello World 

Podemos igualmente anexar um objeto ao objeto exports:

data.js

module.exports = { 
   firstName: 'James', 
   lastName: 'Bond' 
} 

vamos agora usar o módulo no ficheiro app.js:

app.js

var person = require('./data.js'); 
console.log(person.firstName + ' ' + person.lastName); 

Output:

C:\> node app.js 
James Bond

Módulos externos

Módulos externos são módulos construídos por entidades terceiras, os quais temos de descarregar e instalar, usando a ferramenta npm, e depois integrar na nossa aplicação com a função require().

npm

O NPM Package Manager (NPM) é uma ferramenta de linha de comando que instala, atualiza ou desinstala os pacotes node.js. no seu aplicativo. Também é um repositório online para pacotes node.js. de código aberto. A comunidade de node.js em todo o mundo cria módulos úteis e publica-os como pacotes neste repositório.

O NPM está incluído na instalação do node.js. Depois de instalar o node.js, verifique a instalação do NPM escrevendo o seguinte comando no terminal ou no prompt da linha de
comandos:

C:\> npm -v 
2.11.3 

Se possui uma versão mais antiga do NPM, pode atualizá-la para a versão mais recente usando o seguinte comando:

:\> npm install npm -g 

Para aceder à ajuda do NPM, escreva npm help no prompt da linha de comandos ou na janela do termina:

C:\> npm help

O NPM opera em dois modos: global e local. No modo global, o NPM executa operações que afetam todos os aplicativos node.js. no computador, enquanto no modo local, o NPM executa operações para o diretório local específico que afeta apenas uma aplicação nesse diretório.

Instalação local

Use o comando a seguir para instalar qualquer módulo externo na pasta local do projeto node.js.

C:\>npm install <package name>

Por exemplo, o comando a seguir instalará o ExpressJS na pasta MyNodeProj.

C:\MyNodeProj> npm install express 

Todos os módulos instalados usando o NPM são instalados na pasta node_modules. O comando acima criará a pasta ExpressJS na pasta node_modules na pasta raiz do seu projeto e instalará o Express.js lá.

Adicionar dependência ao ficheiro package.json

Use –save no comando install para adicionar entrada de dependência no package.json da sua aplicação.

Por exemplo, o comando a seguir instalará o ExpressJS na sua aplicação e também adicionará a entrada de dependência no package.json.

C:\MyNodeProj> npm install express --save

O package.json do projeto NodejsConsoleApp será semelhante ao mostrado abaixo.

package.json

{ 

  "name": "NodejsConsoleApp", 
  "version": "0.0.0", 
  "description": "NodejsConsoleApp", 
  "main": "app.js", 
  "author": { 
    "name": "Dev", 
    "email": "" 
  }, 
 "dependencies": { 
   "express": "^4.13.3" 
 }
}

Instalação global

O NPM também pode instalar pacotes globalmente, para que todas as aplicações node.js. desse computador possam importar e usar os pacotes instalados. O NPM instala pacotes globais na pasta / / local / lib / node_modules. Aplique -g no comando install para instalar o pacote globalmente.

Por exemplo, o comando a seguir instalará o ExpressJS globalmente.

C:\MyNodeProj> npm install -g express

Atualizar pacotes

Para atualizar um pacote instalado localmente no seu projeto node.js., navegue no prompt de linha de comandos ou na janela do terminal para a pasta do projeto e escreva o seguinte comando de atualização:

C:\MyNodeProj> npm update <package name> 

O comando a seguir atualizará o módulo ExpressJS existente para a versão mais recente:

C:\MyNodeProj> npm update express 

Desinstalar pacotes

Use o seguinte comando para remover um pacote local do seu projeto:

C:\>npm uninstall <package name> 

O comando a seguir desinstalará o ExpressJS da aplicação:

C:\MyNodeProj> npm uninstall express