Comparando CommonJS e AMD/RequireJS

Introdução

Servidores web não similares como Apache e Microsoft IIS, ambos pré-configurados, o node.js é bem diferente. Com o node.js, os desenvolvedores constroem servidores web a partir do zero. Espera-se que as habilidades de codificação de um desenvolvedor protejam o servidor web. Assim, Node.js difere do Apache e o resto.

Neste artigo, vamos focar em dois módulos principais do sistema – AMD e Common.js – no node.js. Antes de compararmos os dois, devemos discutir as diferenças entre os dois módulos do sistema. Duas perguntas orientadoras que nos ajudam a comparar os dois são: qual deles é mais rápido ao carregar módulos no browser ou a partir dele e como converter um módulo do sistema para herdar algumas características de outro módulo do sistema.

Este artigo não focará no básico do node.js e do javascript. Ele não irá cobrir tópicos como “como instalar node.js”, “como usar npm ou nave para instalar pacotes”, ou “versões diferentes do node.js para projetos diferentes”. Nosso propósito é resolver a confusão entre AMD e Common.js. Portanto, vamos enfatizar levemente os módulos do núcleo em node.js, um par de funções e variáveis, e eventualmente direcionar nossa atenção para AMD e Common.js e como podemos converter um dos módulos do sistema para carregar módulos mais rapidamente no navegador.

Módulos do núcleo, do arquivo e do nó externo

No node.js, há três módulos principais importantes; Módulos do núcleo, do arquivo e do nó externo. Vamos começar com o módulo de arquivo primeiro porque é mais fácil de entender.

• Módulo de arquivo:
  Desse modo como os outros dois modelos, o modelo de arquivo é um modelo baseado em um caminho relativo. Porquê? Digamos que você deveria exportar um módulo através da seguinte sintaxe:

 module.exports = foo { 'something' : 123 } ; 

 var foo = function () { console.log('foo called'); };

module.exports = { b : b };

module.exports.bar = function () {console.log('bar called');}; 

module.exports.bas = function () {console.log('bas called');};

A forma como os módulos são carregados ou importados em arquivos é bem diferente dos módulos do núcleo e do nó_externo; é por isso que os outros dois também são conhecidos como módulos não-relativos.

Note: existem diversas formas de exportar módulos/arquivos em node.js. A função Anonymous é outra forma de exportar um módulo de um arquivo.

• Core Modules:
  Os próximos módulos que incluem os três módulos principais no node.js são os módulos do núcleo. Os módulos do núcleo são módulos não-relativos. Eles são muito diferentes dos módulos de arquivos, especialmente quando você está exigindo (ou importando) módulos em arquivos.

Por exemplo, se nós fossemos consumir o módulo de caminho no node.js, que conserta cortes para ser específico do SO, cuida do . e … no caminho, e também remove as barras duplicadas, não incluiríamos o caminho relativo:

var require = require('path') console.log (path.normalize ('/foo/bar/......'));

• módulos_de_nó externo:
  Esses módulos caem em algum lugar entre os módulos do núcleo e os módulos baseados em arquivos. Os módulos de nó_externo são bastante semelhantes aos módulos baseados em arquivos, especialmente quando você está exportando um módulo.

module.exports = function () {console.log('called node modules!');} 

No entanto, quando você está carregando módulos, eles se tornam bastante diferentes.

var bar = require('bas');bas(); // 

Adicionalmente, o node.js fornece algumas características globais importantes com características úteis, que não discutiremos em detalhes. timer,console, _filename e_dirname, e processo são todos exemplos de globais importantes no node.js. Por exemplo, _filename e _dirname estão disponíveis em cada arquivo e dão acesso ao caminho completo e diretório para o módulo atual.

Agora temos um breve entendimento dos módulos no node.js, vamos passar ao aspecto principal, onde diferenciamos os módulos CommonJS e AMD. Vamos abordar os problemas de “porque Common.js é tão lento no carregamento de módulos do browser” e “como podemos convertê-lo via browserify para herdar certas características do AMD e Require.js”. .

Introduzindo CommonJS e AMD

 CommonJS is a great module for the server side environment, especially when you have immediate access to the filesystem. However, using the same module system in the browser may be less reliable and extremely slow. 

Por exemplo, vamos considerar como os dois módulos são carregados no lado do servidor:

var foo = require('./foo');var bar = require('./bar');// more code here 

Olhando para o exemplo acima, é considerado uma boa prática no lado do servidor quando um módulo é carregado enquanto o outro módulo espera que outro módulo seja analisado.

Em outras palavras, quando o módulo foo está sendo carregado, a barra não será analisada ou processada até que o foo seja completamente carregado. Mesmo o servidor pode não estar ciente do módulo de barras até que seja feito com o módulo foo.

Usar o mesmo sistema de módulos no navegador não é considerado uma boa idéia, pois cada sistema de módulos precisaria acionar uma solicitação HTTP para o servidor. Isto é muito menos eficiente e menos confiável no ambiente do servidor. Isto degrada a experiência do usuário no lado do cliente. Este problema poderia ser resolvido através do carregamento assíncrono de módulos.

É aqui que a AMD entra. AMD, também conhecido como async module definition, foi introduzido para suportar o carregamento assíncrono de módulos no browser –
acaba por resolver o lento ritmo de carregamento de módulos no browser. De acordo com o significado de “assíncrono”, módulos são acionados em momentos diferentes.

Para exportar algo em um arquivo no AMD, nós simplesmente precisamos incluir uma função de callback e retorná-la a partir de uma função de callback definida. Aqui está um exemplo:

 define(, function () { var foo = function () { console.log ('foo was called');}; return foo; // function foo is exported});

Apenas como a sintaxe da variável de exportação no nó.JS, a função definir também pega um argumento especial chamado exportações, que é bastante similar ao do nó.JS.

define(, function (exports) {var bas = exports.log = function () {console.log ('bas.log was called'); };});

A fim de tornar possível carregar dois módulos no navegador, nós precisamos baixar e instalar o RequireJS. Tenha em mente, esta é apenas uma opção que impede os desenvolvedores de usar o código node.JS no navegador.]

Por que precisamos do RequireJS para carregar módulos através da definição assíncrona de módulos?
Aqui está a razão: porque a função Definir, que faz parte do código abaixo (mostrando-nos como podemos carregar mais de um módulo no navegador através da AMD), não é nativa do navegador. Portanto, a melhor opção é acessá-la a partir de uma biblioteca de terceiros. RequireJS é simplesmente um arquivo javascript que você inclui no seu projeto.

define(, function(foo, bar){ //more code here// more code here }); 

Como converter o node.js em Código do Navegador:

Agora, vamos ver como podemos converter CommonJS para se tornar compatível com o AMD/RequireJS via browserify. A conversão do CommonJS via browserify permite que o node.js carregue módulos no browser semelhantes ao AMD/RequireJS.

Vamos instalar o browserify através do seguinte código. Por favor, certifique-se de que você está conectado à internet quando da instalação. O g hifenizado significa simplesmente global.

npm install –g browserify

Pode criar módulos, nomeá-los como clientJS ou qualquer nome que preferir, e eventualmente convertê-los para AMD/RequireJS usando o browserify.

module.exports = function () {console.log('bas was called');}

exports.log = function () {console.log('bar.log was called');}

Agora, para converter o código acima para ser compatível com AMD, em outras palavras, para carregar módulos de forma assíncrona, precisamos fazê-lo através dos seguintes argumentos de linha de comando:

browserify client.js -o amdmodule.js

Pode atribuir qualquer nome que prefira como cliente. Não deve ser sempre client.js, mas client.js também é preferível. Lembre-se, é apenas um arquivo. Além disso, você pode verificar mais configurações sobre o browserify em http://browserify.org/.

Wrapping up:

Finalmente, você deve notar que nem todos os módulos node.JS podem ser convertidos para funcionar efetivamente no browser. Aqueles que dependem de funcionalidades que estão disponíveis no lado do servidor não funcionam de todo no browser.

Acabei de introduzir o AMD/RequireJS como uma solução que permite o carregamento assíncrono de módulos no browser, o que é considerado uma boa prática. Carregar módulos de forma assíncrona é muito mais rápido e confiável do que usar o CommonJS no navegador.