O JavaScript é uma das linguagens de programação mais usadas no mundo. É a linguagem comum no mundo da web e é usada por todos os navegadores. O nascimento de JavaScript remonta à era do Netscape, e seu conteúdo principal foi desenvolvido às pressas para combater a Microsoft e participar da feroz guerra do navegador na época. Devido ao lançamento prematuro, algumas de suas maus características inevitavelmente resultaram em.
Embora seu tempo de desenvolvimento seja curto, o JavaScript ainda possui muitos recursos poderosos, exceto o recurso de compartilhar um espaço de nome global para cada script.
Depois que a página da Web for carregada com o código JavaScript, ela é injetada no espaço de nome global e compartilhará o mesmo espaço de endereço que todos os outros scripts carregados, o que levará a muitos problemas de segurança, conflitos e alguns problemas comuns, dificultando os bugs e difíceis de resolver.
Mas, felizmente, o Node estabeleceu algumas especificações para o JavaScript do lado do servidor e também implementa o padrão do módulo Commonjs. Neste padrão, cada módulo tem seu próprio contexto e se distingue de outros módulos. Isso significa que os módulos não poluem o escopo global, porque não há o chamado escopo global e os módulos não interferem entre si.
Neste capítulo, aprenderemos sobre vários módulos diferentes e como carregá -los.
A divisão do código em uma série de módulos bem definidos pode ajudá-lo a controlar seu aplicativo. Abaixo, aprenderemos a criar e usar seus próprios módulos.
Aprenda como os nó carregam módulos
No nó, os módulos podem ser referenciados através de caminhos de arquivo ou nomes de módulos. Se um módulo não essencial for referenciado pelo nome, o nó acabará por aludir o nome do módulo ao caminho do arquivo do módulo correspondente. E esses módulos principais que contêm funções principais serão pré -carregados quando o nó iniciar.
Os módulos que não são do núcleo incluem módulos de terceiros instalados usando o NPM (Node Package Manager), bem como módulos locais criados por você ou seus colegas.
Cada módulo importado pelo script atual exporá um conjunto de APIs expostas ao programador. Antes de usar o módulo, você precisa usar a função de necessidade para importá -la, assim:
A cópia do código é a seguinte:
var módulo = requer ('module_name')
O código acima importará um módulo chamado Module_Name. Pode ser um módulo principal ou um módulo instalado com o NPM. A função requerida retorna um objeto que contém todas as APIs públicas do módulo. Dependendo do módulo, o objeto retornado pode ser qualquer valor JavaScript, pode ser uma função ou um objeto que contém uma série de atributos (funções, matrizes ou qualquer objeto JavaScript).
Módulo de exportação
O sistema de módulo Commonjs é a única maneira de compartilhar objetos e funções entre os arquivos no nó. Para um programa muito complexo, você deve reconstruir algumas classes, objetos ou funções em uma série de módulos reutilizáveis bem definidos. Para usuários do módulo, o módulo expõe apenas o código que você especificou ao mundo exterior.
No exemplo a seguir, você entenderá que no nó, arquivos e módulos correspondem um por um. Criamos um arquivo chamado Circle.js, que exporta apenas o construtor do círculo para o exterior.
A cópia do código é a seguinte:
círculo de funções (x, y, r) {
função r_squared () {
retornar math.pow (r, 2);
}
área de função () {
return math.pi * r_squared ();
}
retornar {área: área};
}
module.exports = circ;
A coisa mais importante no código é a última linha, que define o que o módulo exporta para o exterior. O módulo é uma variável especial, que representa o próprio módulo atual, e o Module.Exports é um objeto exportado do módulo. Pode ser qualquer objeto. Neste exemplo, exportamos o construtor do círculo para que os usuários do módulo possam usar este módulo para criar instâncias do círculo.
Você também pode exportar alguns objetos complexos, o Module.Exports é inicializado em um objeto vazio e você exporta o que deseja expor ao mundo exterior como os atributos do objeto Module.Exports. Por exemplo, você projetou um módulo que expõe um conjunto de funções para o exterior:
A cópia do código é a seguinte:
function printa () {
console.log ('a');
}
function printb () {
console.log ('b');
}
function printc () {
console.log ('c');
}
module.exports.printa = printA;
module.exports.printb = printb;
module.exports.pi = math.pi;
Este módulo exporta duas funções (PrintA e PrintB) e um número (PI), e o código de chamada se parece com o seguinte:
A cópia do código é a seguinte:
var myModule2 = requer ('./ myModule2');
mymodule2.printa (); // -> a
mymodule2.printb (); // -> b
console.log (mymodule2.pi); // -> 3.141592653589793
Módulo de carregamento
Como mencionado anteriormente, você pode usar a função de requisição para carregar módulos e não se preocupe que a chamada exigir no código afete o espaço para nome global, porque não há conceito de espaço para nome global no nó. Se o módulo existir sem qualquer sintaxe ou erros de inicialização, a função requer retornará o objeto do módulo e você também poderá atribuir esse objeto a qualquer variável local.
Existem vários tipos diferentes de módulos, que podem ser divididos aproximadamente em módulos principais, módulos locais e módulos de terceiros instalados através do NPM. De acordo com o tipo de módulo, existem várias maneiras de se referir a módulos. Vamos aprender sobre esses conhecimentos abaixo.
Carregando o módulo principal
O Node possui alguns módulos compilados em arquivos binários, chamados de módulos principais. Eles não podem ser referenciados por caminhos e só podem ser usados com nomes de módulos. O módulo principal tem a maior prioridade de carga e, mesmo que já exista um módulo de terceiros com o mesmo nome, o módulo principal será carregado primeiro.
Por exemplo, se você deseja carregar e usar o módulo Core HTTP, pode fazer isso:
A cópia do código é a seguinte:
var http = requer ('http');
Isso retornará um objeto que contém o módulo HTTP, que contém as APIs desses módulos HTTP definidos na documentação da API do nó.
Carregando o módulo de arquivo
Você também pode usar caminhos absolutos para carregar módulos do sistema de arquivos:
A cópia do código é a seguinte:
var myModule = requer ('/home/pedro/my_modules/my_module');
Você também pode usar um caminho relativo com base no arquivo atual:
A cópia do código é a seguinte:
var myModule = requer ('../ my_modules/my_module');
var myModule2 = requer ('./ lib/my_module_2');
Preste atenção ao código acima. Você pode omitir a extensão do nome do arquivo. Se o nó não conseguir encontrar esse arquivo, você tentará adicionar um sufixo JS para pesquisar novamente após o nome do arquivo (Nota do tradutor: De fato, além do JS, você também procurará JSON e Node. Para obter detalhes, você poderá ver a documentação oficial do site). Portanto, se existir um arquivo chamado my_module.js no diretório atual, haverá dois métodos de carregamento:
A cópia do código é a seguinte:
var myModule = requer ('./ my_module');
var myModule = requer ('./ my_module.js');
Carregando o módulo de diretório
Você também pode usar o caminho do diretório para carregar o módulo:
A cópia do código é a seguinte:
var myModule = requer ('./ mymoduledir');
O nó assumirá que este diretório é um pacote de módulos e tentará pesquisar o pacote de filmes de definição do pacote.json neste diretório.
Se não for encontrado, o nó assumirá que o ponto de entrada do pacote é o arquivo index.js (Nota do tradutor: Além do index.js, ele também procurará index.node, e o arquivo .node é o pacote de extensão binária do Node, consulte o documento oficial para obter detalhes). O código acima é um exemplo. O nó tentará encontrar o arquivo ./mymoduledir/index.js.
Pelo contrário, se o arquivo package.json for encontrado, o nó tentará analisá -lo e procurar o atributo principal na definição do pacote e, em seguida, usar o valor do atributo principal como o caminho relativo do ponto de entrada. Neste exemplo, se o Package.json for definido da seguinte forma:
A cópia do código é a seguinte:
{
"Nome": "MyModule",
"Main": "./lib/mymodule.js"
}
O nó tentará carregar o ./mymoduledir/lib/mymodule.js arquivo
Carregar do diretório Node_modules
Se os parâmetros da função requisição não forem caminhos relativos ou nomes de módulos principais, o nó será pesquisado no subdiretório Node_modules do diretório atual. Por exemplo, no código a seguir, o nó tentará encontrar o arquivo./node_modules/mymodule.js:
A cópia do código é a seguinte:
var myModule = requer ('mymodule.js');
Se não for encontrado, o nó continuará pesquisando na pasta Node_modules do diretório superior. Se não for encontrado, continue pesquisando no diretório superior até que o módulo correspondente seja encontrado ou o diretório raiz seja atingido.
Você pode usar esse recurso para gerenciar o conteúdo ou os módulos do diretório Node_modules, mas é melhor entregar as tarefas de gerenciamento de módulos ao NPM (consulte o Capítulo 1). O diretório local Node_modules é o local padrão para o módulo de instalação do NPM. Este design associa o Node e o NPM juntos. Geralmente, como desenvolvedor, você não precisa se importar muito com esse recurso. Você pode simplesmente instalar, atualizar e excluir pacotes usando o NPM, o que ajudará você a manter o diretório Node_modules.
Módulo de cache
O módulo será armazenado em cache após o primeiro carregamento bem -sucedido, ou seja, se o nome do módulo for resolvido no mesmo caminho do arquivo, todas as chamadas exigem ('myModule') retornará exatamente o mesmo módulo.
Por exemplo, existe um módulo chamado my_module.js que contém o seguinte conteúdo:
A cópia do código é a seguinte:
console.log ('módulo my_module inicializando ...');
module.exports = function () {
console.log ('oi!');
};
console.log ('my_module inicializado.');
Em seguida, use o código a seguir para carregar o módulo:
A cópia do código é a seguinte:
var myModuleInstance1 = requer ('./ my_module');
Produz a seguinte saída:
A cópia do código é a seguinte:
Módulo My_module Inicializando ...
my_module inicializado
Se importarmos duas vezes:
A cópia do código é a seguinte:
var myModuleInstance1 = requer ('./ my_module');
var myModuleInstance2 = requer ('./ my_module');
A saída ainda está:
A cópia do código é a seguinte:
Módulo My_module Inicializando ...
my_module inicializado
Ou seja, o código de inicialização do módulo é executado apenas uma vez. Quando você constrói seu próprio módulo, se o código de inicialização do módulo contiver código que pode ter efeitos colaterais, você deverá prestar atenção especial a esse recurso.
resumo
O Node cancelou o escopo global padrão do JavaScript e, em vez disso, adotou o sistema de módulos Commonjs, para que você possa organizar melhor seu código e evitar muitos problemas e bugs de segurança. Você pode usar a função Requer para carregar módulos principais, módulos de terceiros ou carregar seus próprios módulos de arquivos e diretórios.
Você também pode usar caminhos relativos ou absolutos para carregar módulos que não são do núcleo. Se você colocar o módulo no diretório Node_modules ou para módulos instalados com o NPM, também poderá usar diretamente o nome do módulo para carregar.
Nota do tradutor:
Recomenda -se que os leitores leiam os capítulos do módulo do documento oficial. Pessoalmente, sinto que é mais claro que o autor. Um exemplo muito representativo foi anexado, que será de grande ajuda para entender o carregamento do módulo do nó. O seguinte também é citado:
A cópia do código é a seguinte:
Use requer (x) para carregar módulos sob o caminho y
1. Se x é o módulo principal,
um. Carregue e retorne o módulo principal
b. Fim
2. Se x começar com './' ou '/' ou '../
um. Load_as_file (y + x)
b. Load_as_directory (y + x)
3. Load_node_modules (x, dirname (y))
4. Jogue uma exceção: "Não encontrado"
Load_as_file (x)
1. Se x for um arquivo, carregue x como um script JavaScript e termine após o carregamento
2. Se X.js for um arquivo, carregue x.js como um script JavaScript e termine após o carregamento
3. Se x.Node for um arquivo, carregue x.Node como plug-in binário do nó e termine após o carregamento.
Load_as_directory (x)
1. Se houver o arquivo x/package.json,
um. Palsés X/Package.json e encontre o campo "Principal".
b. Também m = x + (valor do campo principal)
c. Load_as_file (m)
2. Se houver o arquivo x/index.js, carregue x/index.js como um script JavaScript e termine após o carregamento.
3. Se houver o arquivo x/index.node, carregue x/index.node como plug-in binário do nó e termine após o carregamento.
Load_node_modules (x, start)
1. Também dirs = node_modules_paths (Iniciar)
2. Faça as seguintes operações para cada diretório Dir Under Dirs:
um. Load_as_file (dir/x)
b. Load_as_directory (dir/x)
Node_modules_paths (Iniciar)
1. Também partes = divisão do caminho (inicial)
2. Também raiz = índice de primeira instância de "node_modules" em partes, ou 0
3. Também i = contagem de peças - 1
4. Também dirs = []
5. Enquanto eu> raiz,
um. Se as partes [i] = "node_modules", o Operação de acompanhamento continuará, caso contrário, o próximo loop
c. Dir = junção do caminho (partes [0 .. i] + "node_modules")
b. Dirs = Dirs + Dir
c. Também i = i - 1
6. Voltar aos diretores