Modulos - Node.js

O Node.js utiliza um sistema modular. Isso significa que toda a funcionalidade incorporada é dividida em pacotes ou módulos separados. Um módulo representa um bloco de código que pode ser reutilizado em outros lugares.

Quando necessário, podemos importar os módulos. As suas funcionalidades são podem ser encontrados na documentação.

No mundo do JavaScript, existem diferentes sistemas de módulos. Por padrão, o Node.js aplica o sistema de módulos CommonJS, que considera cada arquivo como um módulo e utiliza a função require(), na qual se passa o nome do módulo para carregar os módulos. Por exemplo, na primeira aplicação do tema anterior, para obter e processar uma solicitação, foi necessário importar o módulo http:

Após importar o módulo, podemos usar toda a funcionalidade definida nele, que também pode ser encontrada na documentação.

De maneira similar, podemos carregar e usar outros módulos incorporados. Por exemplo, usemos o módulo os, que fornece informações sobre o ambiente e o sistema operacional. Para isso, definimos um arquivo app.js com o seguinte código:

const os = require("os");
// Obteremos o nome do usuário atual
const userName = os.userInfo().username;
console.log(userName);

Executamos esta aplicação com o comando node app.js, e o nome do usuário atual será exibido no console:

c:\app> node app.js
programicio

Criando Seus Próprios Módulos

Não estamos limitados apenas aos módulos incorporados e, quando necessário, podemos criar nossos próprios módulos. Assim, adicionamos ao diretório da aplicação (onde está o arquivo app.js) um novo arquivo greeting.js e definimos o seguinte código nele:

No arquivo app.js, importamos nosso módulo:

Diferentemente dos módulos incorporados, para importar nossos módulos, precisamos passar o caminho relativo com o nome do arquivo (a extensão do arquivo é opcional) para a função require. Executamos a aplicação:

c:\app> node app.js
Hello Programício

A string definida no arquivo greeting.js é exibida no console.

Vale notar que, dentro do módulo, podemos obter informações sobre o próprio módulo usando o objeto especial module. Por exemplo, alteramos o arquivo greeting.js da seguinte forma:

Reexecutamos o arquivo app.js. No meu caso, a saída será a seguinte:

c:\app> node app.js
{
    id: '/Users/programicio/Documents/app/greeting.js',
    path: '/Users/programicio/Documents/app',
    exports: {},
    filename: '/Users/programicio/Documents/app/greeting.js',
    loaded: false,
    children: [],
    paths: [
    '/Users/programicio/Documents/app/node_modules',
    '/Users/programicio/Documents/node_modules',
    '/Users/programicio/node_modules',
    '/Users/node_modules',
    '/node_modules'
    ]
}

Aqui, vemos que o objeto module contém várias propriedades que permitem obter o diretório e o caminho para o arquivo do módulo atual, além dos caminhos onde os módulos serão procurados.

Exportando de um Módulo

Agora, vamos definir um conteúdo mais interessante no módulo greeting.js. O que um módulo pode definir? Essencialmente, um módulo é um arquivo de código JavaScript comum, que pode definir variáveis, constantes, funções e chamar suas próprias funções e outras funções. Por exemplo, vamos alterar o arquivo greeting.js da seguinte forma:

const currentDate = new Date();

// Dependendo da hora, exibimos uma mensagem específica
function printMessage(name) {
    const hour = currentDate.getHours();
    if (hour >= 18) {
        console.log("Boa noite,", name);
    } else if (hour >= 12) {
        console.log("Boa tarde,", name);
    } else {
        console.log("Bom dia,", name);
    }
}

Aqui, definimos a constante currentDate, que armazena a data atual. Também definimos a função printMessage, que recebe o nome do usuário e, dependendo da hora atual, exibe uma mensagem específica.

Podemos usar a constante currentDate e a função printMessage dentro do módulo greeting.js, mas elas não estão acessíveis externamente. Para verificar a disponibilidade no arquivo app.js, exibimos o módulo greeting no console:

const greeting = require("./greeting");
console.log(greeting); // {}

Executamos o arquivo app.js:

c:\app> node app.js
{}
c:\app>

Vemos que o módulo greeting representa um objeto vazio. No entanto, na realidade, ele contém uma constante e uma função. Para acessá-las em outros módulos, precisamos exportá-las. Para isso, alteramos o arquivo greeting.js da seguinte forma:

const currentDate = new Date();
exports.date = currentDate;  // Exportando a constante currentDate como date
    
// Exportando a função
exports.printMessage = function (name) {
    const hour = currentDate.getHours();
    if (hour >= 18) {
        console.log("Boa noite,", name);
    } else if (hour >= 12) {
        console.log("Boa tarde,", name);
    } else {
        console.log("Bom dia,", name);
    }
}

Para tornar as variáveis/constantes ou funções de um módulo acessíveis, precisamos exportá-las. Para isso, usamos o objeto exports.

Agora, alteramos o arquivo app.js:

const os = require("os");
const greeting = require("./greeting");
    
// Nome do usuário atual
const userName = os.userInfo().username;
    
console.log(`Data da solicitação: ${greeting.date}`);
greeting.printMessage(userName);

Reexecutamos a aplicação. No meu caso, o resultado será:

c:\app> node app.js
Data da solicitação: Tue Nov 21 2023 18:23:06
Boa tarde, programicio

Importando Componentes de um Módulo

No exemplo acima, importamos toda a funcionalidade do módulo como um todo e, através do nome greeting, pudemos acessar essa funcionalidade:

No entanto, também podemos importar componentes individualmente:

// Obtendo componentes do módulo individualmente
const { date, printMessage } = require("./greeting");
    
// Nome do usuário atual
const userName = "Tom";
    
console.log(`Data da solicitação: ${date}`);
printMessage(userName);

Aqui, para obter os componentes do módulo, indicamos seus nomes entre chaves:

Podemos definir um nome personalizado para um componente do módulo:

// A função print representa a função printMessage
const print = require("./greeting").printMessage;
    
const userName = "Bob";
print(userName);

Definindo Construtores e Objetos em um Módulo

Além de definir funções ou propriedades simples, um módulo pode definir objetos ou funções construtoras, que são usadas para criar objetos. Vamos adicionar um novo arquivo user.js ao diretório do projeto:

function User(name, age) {
    this.name = name;
    this.age = age;
    this.print = function () {
        console.log(`Nome: ${this.name}  Idade: ${this.age}`);
    }
}
User.prototype.sayHi = function() {
    console.log(`Olá, meu nome é ${this.name}`);
};
  
module.exports = User;

Aqui, definimos uma função construtora padrão User, que aceita dois parâmetros. Todo o módulo agora aponta para esta função construtora:

Vamos importar e usar este módulo no arquivo app.js:

// Obtendo a função printMessage
const User = require("./user.js");
    
const programicio = new User("Programício", 22);
programicio.print();
programicio.sayHi();

Executamos a aplicação:

c:\app> node app.js
Nome: Programício  Idade: 22
Olá, meu nome é Programício