Confronto tra CommonJS e AMD/RequireJS

Introduzione

A differenza dei server web come Apache e Microsoft IIS, entrambi preconfigurati, node.js è molto diverso. Con node.js, gli sviluppatori costruiscono server web da zero. Ci si aspetta che le capacità di codifica di uno sviluppatore salvaguardino il server web. Così, Node.js differisce da Apache e il resto.

In questo articolo, ci concentreremo su due principali moduli di sistema – AMD e Common.js – in node.js. Prima di confrontarli, dobbiamo discutere le differenze tra i due moduli di sistema. Due domande guida che ci aiutano a confrontare i due sono: quale dei due è più veloce quando si caricano i moduli nel o dal browser e come convertire un modulo di sistema per ereditare alcune caratteristiche dell’altro modulo di sistema.

Questo articolo non si concentrerà sulle basi di node.js e javascript. Non tratterà argomenti come “come installare node.js”, “come usare npm o nave per installare i pacchetti”, o “diverse versioni di node.js per diversi progetti”. Il nostro scopo è quello di risolvere la confusione tra AMD e Common.js. Pertanto, enfatizzeremo leggermente i moduli core in node.js, un paio di funzioni e variabili, e alla fine dirigeremo la nostra attenzione su AMD e Common.js e su come possiamo convertire uno dei moduli di sistema per caricare i moduli più velocemente nel browser.

Core, File e Moduli esterni di node

In node.js, ci sono tre moduli principali importanti; Core, file e moduli esterni di node. Cominciamo prima con il modulo file perché è più facile da capire.

• Modulo file:
  A differenza degli altri due modelli, il modello file è un modello basato sul percorso relativo. Perché? Supponiamo che tu voglia esportare un modulo con la seguente sintassi:

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

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

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

module.exports = { b : b };

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

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

Il modo in cui i moduli sono caricati o importati nei file è abbastanza diverso dai moduli core e external_node; ecco perché gli altri due sono anche conosciuti come moduli non basati su percorsi relativi.

Nota: ci sono diversi modi di esportare moduli/file in node.js. La funzione anonima è un altro dei modi per esportare un modulo da un file.

• Moduli core:
  I moduli successivi che includono i tre moduli principali in node.js sono i moduli core. I moduli core sono moduli non basati sulla relazione. Sono molto diversi dai moduli di file, specialmente quando si richiedono (o si importano) moduli in file.

Per esempio, se dovessimo consumare il modulo path in node.js, che corregge le slash per essere specifico del sistema operativo, si prende cura di . e .. nel percorso, e rimuove anche gli slash duplicati, non includeremmo il percorso relativo:

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

• moduli external_node:
  Questi moduli si collocano a metà strada tra il core e i moduli basati su file. I moduli external_node sono abbastanza simili a quelli basati su file, specialmente quando si esporta un modulo.

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

Tuttavia, quando si caricano i moduli, diventano abbastanza diversi.

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

Inoltre, node.js fornisce alcuni importanti globali con caratteristiche utili, che non discuteremo in dettaglio. timer,console, _filename e_dirname, e process sono tutti esempi di importanti globali in node.js. Per esempio, _filename e _dirname sono disponibili in ogni file e danno accesso al percorso completo e alla directory del modulo corrente.

Ora che abbiamo una breve comprensione dei moduli in node.js, passiamo all’aspetto principale, dove differenziamo i moduli CommonJS e AMD. Affronteremo i problemi del “perché Common.js è così lento nel caricare i moduli dal browser” e “come possiamo convertirlo tramite browserify per ereditare alcune caratteristiche di AMD e Require.js”. .

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

Per esempio, consideriamo come i due moduli vengono caricati nell’ambiente lato server:

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

Guardando l’esempio sopra, è considerata una buona pratica sul lato server quando un modulo viene caricato mentre l’altro modulo attende che un altro modulo venga analizzato.

In altre parole, quando il modulo pippo viene caricato, la barra non verrà analizzata o processata fino a quando il pippo non sarà stato caricato completamente. Anche il server potrebbe non essere consapevole del modulo bar fino a quando non ha finito con il modulo pippo.

Utilizzare lo stesso sistema di moduli nel browser non è considerato una buona idea perché ogni sistema di moduli avrebbe bisogno di attivare una richiesta HTTP al server. Questo è molto meno efficiente e meno affidabile nell’ambiente server. Degrada l’esperienza dell’utente sul lato client. Questo problema potrebbe essere risolto tramite il caricamento asincrono dei moduli.

Ecco dove entra in gioco AMD. AMD, noto anche come definizione asincrona del modulo, è stato introdotto per supportare il caricamento asincrono dei moduli nel browser –
e alla fine risolve la lentezza del caricamento dei moduli nel browser. In linea con il significato di “asincrono”, i moduli vengono attivati in tempi diversi.

Per esportare qualcosa in un file in AMD, dobbiamo semplicemente includere una funzione callback e restituirla da una funzione callback define. Ecco un esempio:

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

Proprio come la sintassi della variabile export in node.JS, anche la funzione define prende un argomento speciale chiamato exports, che è abbastanza simile a quello in node.JS.

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

Per rendere possibile il caricamento di due moduli nel browser, dobbiamo scaricare e installare RequireJS. Tenete a mente che questa è solo un’opzione che impedisce agli sviluppatori di usare il codice node.JS nel browser]

Perché abbiamo bisogno di RequireJS per poter caricare i moduli tramite la definizione asincrona del modulo?
Ecco il motivo: perché la funzione Define, che fa parte del codice qui sotto (che ci mostra come possiamo caricare più di un modulo nel browser tramite AMD), non è nativa del browser. Pertanto, l’opzione migliore è quella di accedervi da una libreria di terze parti. RequireJS è semplicemente un file javascript che includete nel vostro progetto.

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

Come convertire node.js in codice per browser:

Ora, vediamo come possiamo convertire CommonJS per diventare compatibile con AMD/RequireJS tramite browserify. La conversione di CommonJS tramite browserify permette a node.js di caricare i moduli nel browser in modo simile a AMD/RequireJS.

Installiamo browserify tramite il seguente codice. Assicurati di essere connesso a internet durante l’installazione. La g con il trattino significa semplicemente globale.

npm install –g browserify

Puoi creare moduli, chiamarli come clientJS o qualsiasi nome tu preferisca, ed eventualmente convertirli in AMD/RequireJS usando browserify.

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

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

Ora, per convertire il codice di cui sopra per essere compatibile con AMD, in altre parole, per caricare i moduli in modo asincrono, dobbiamo farlo tramite i seguenti argomenti della riga di comando:

browserify client.js -o amdmodule.js

Puoi assegnare qualsiasi nome che preferisci per essere il client. Non dovrebbe essere sempre client.js ma anche client.js è preferibile. Ricorda che è solo un file. Inoltre, puoi controllare ulteriori configurazioni su browserify a http://browserify.org/.

Wrapping up:

Infine, dovresti notare che non tutti i moduli node.JS possono essere convertiti per funzionare efficacemente nel browser. Quelli che dipendono da caratteristiche che sono disponibili sul lato server non funzioneranno affatto nel browser.

Ho appena introdotto AMD/RequireJS come soluzione che permette il caricamento asincrono dei moduli nel browser, che è considerato una buona pratica. Caricare i moduli in modo asincrono è molto più veloce e più affidabile che usare CommonJS nel browser.

Io ho appena introdotto AMD/RequireJS come soluzione che permette il caricamento asincrono dei moduli nel browser.