Sammenligning af CommonJS og AMD/RequireJS

Introduktion

I modsætning til webservere som Apache og Microsoft IIS, der begge er forudkonfigureret, er node.js helt anderledes. Med node.js bygger udviklere webservere fra bunden. En udviklers kodningsevner forventes at sikre webserveren. Derfor adskiller Node.js sig fra Apache og resten.

I denne artikel vil vi fokusere på de to vigtigste systemmoduler – AMD og Common.js – i node.js. Før vi sammenligner de to, skal vi diskutere forskellene mellem de to systemmoduler. To vejledende spørgsmål, der hjælper os med at sammenligne de to, er: Hvilket af dem er hurtigere, når der indlæses moduler i eller fra browseren, og hvordan man konverterer et systemmodul til at arve nogle funktioner fra et andet systemmodul.

Denne artikel vil ikke fokusere på det grundlæggende i node.js amd javascript. Den vil ikke dække emner som “hvordan man installerer node.js”, “hvordan man bruger npm eller nave til at installere pakker”, eller “forskellige versioner af node.js til forskellige projekter”. Vores formål er at løse forvirringen mellem AMD og Common.js. Derfor vil vi lægge let vægt på kernemodulerne i node.js, et par funktioner og variabler og til sidst rette opmærksomheden mod AMD og Common.js, og hvordan vi kan konvertere et af systemmodulerne for at indlæse moduler hurtigere i browseren.

Kerne-, fil- og eksterne node-moduler

I node.js er der tre vigtige hovedmoduler; kerne-, fil- og eksterne node-moduler. Lad os kickstarte det med filmodulet først, fordi det er nemmere at forstå.

• Filmodul:
  I modsætning til de to andre modeller er filmodellen en relativ-pad-baseret model. Hvorfor? Lad os sige, at du skulle eksportere et modul via følgende syntaks:

 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');};

Den måde, hvorpå moduler indlæses eller importeres i filer, er helt anderledes end core- og external_node-modulerne; derfor kaldes de to andre også for ikke-relativt baserede moduler.

Bemærk: Der er forskellige måder at eksportere moduler/filer på i node.js. Anonym funktion er en anden måde at eksportere et modul fra en fil på.

• Kernemoduler:
  De næste moduler, der omfatter de tre hovedmoduler i node.js, er kernemodulerne. Kernemoduler er ikke-relative baserede moduler. De er meget forskellige fra filmoduler, især når du kræver (eller importerer) moduler i filer.

For eksempel, hvis vi skulle forbruge path-modulet i node.js, som retter op på skråstreger, så de er OS-specifikke, tager sig af . og .. i stien og også fjerner dobbelte skråstreger, ville vi ikke medtage den relative sti:

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

• external_node-moduler:
  Disse moduler ligger et sted mellem core- og filbaserede moduler. external_node-moduler ligner ret meget de filbaserede, især når du eksporterer et modul.

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

Men når du indlæser moduler, bliver de helt anderledes.

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

Dertil kommer, at node.js giver nogle vigtige globale med nyttige funktioner, som vi ikke vil diskutere i detaljer. timer,console, _filename og_dirname, og process er alle eksempler på vigtige globals i node.js. For eksempel er _filename og _dirname tilgængelige i alle filer og giver adgang til den fulde sti og mappe for det aktuelle modul.

Nu da vi har en kort forståelse af moduler i node.js, skal vi gå videre til det vigtigste aspekt, hvor vi skelner mellem CommonJS og AMD-moduler. Vi vil tage fat på problemerne med “hvorfor Common.js er så langsom til at indlæse moduler fra browseren” og “hvordan vi kan konvertere det via browserify til at arve visse funktioner fra AMD og Require.js”. .

Introduktion til CommonJS og 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. 

Lad os f.eks. se på, hvordan de to moduler indlæses i serverside-miljøet:

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

Hvis vi ser på eksemplet ovenfor, betragtes det som en god praksis på serversiden, når det ene modul indlæses, mens det andet modul venter på, at et andet modul bliver analyseret.

Med andre ord, når foo-modulet bliver indlæst, vil bar ikke blive analyseret eller behandlet, før foo er indlæst helt af. Selv serveren er måske ikke klar over bar-modulet, før den er færdig med foo-modulet.

Det anses ikke for en god idé at bruge det samme modulsystem i browseren, fordi hvert modulsystem ville skulle udløse en HTTP-anmodning til serveren. Dette er meget mindre effektivt og mindre pålideligt i servermiljøet. Det forringer brugeroplevelsen på klientsiden. Dette problem kunne løses via asynkron indlæsning af moduler.

Det er her, AMD kommer ind i billedet. AMD, også kendt som asynkron moduldefinition, blev indført for at understøtte asynkron indlæsning af moduler i browseren –
det løser i sidste ende den langsomme hastighed for indlæsning af moduler i browseren. I overensstemmelse med betydningen af “asynkron” udløses moduler på forskellige tidspunkter.

For at eksportere noget i en fil i AMD skal vi blot inkludere en callback-funktion og returnere den fra en define callback-funktion. Her er et eksempel:

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

Nøjagtig som syntaksen for eksportvariable i node.JS tager define-funktionen også et særligt argument kaldet exports, som er ganske lig det i node.JS.

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

For at gøre det muligt at indlæse to moduler i browseren, skal vi downloade og installere RequireJS. Husk på, at dette blot er en mulighed, der forhindrer udviklere i at bruge node.JS-kode i browseren.]

Hvorfor har vi brug for RequireJS for at kunne indlæse moduler via den asynkrone moduldefinition?
Her er årsagen: fordi funktionen Define, som er en del af koden nedenfor (der viser os, hvordan vi kan indlæse mere end ét modul i browseren via AMD), ikke er indbygget i browseren. Derfor er den bedste mulighed at få adgang til den fra et bibliotek fra en tredjepart. RequireJS er simpelthen en javascript-fil, som du inkluderer i dit projekt.

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

Sådan konverteres node.js til browserkode:

Nu skal vi se, hvordan vi kan konvertere CommonJS til at blive kompatibelt med AMD/RequireJS via browserify. Konvertering af CommonJS via browserify gør det muligt for node.js at indlæse moduler i browseren på samme måde som AMD/RequireJS.

Lad os installere browserify via følgende kode. Sørg for, at du har forbindelse til internettet, mens du installerer. Det med bindestreg g betyder simpelthen global.

npm install –g browserify

Du kan oprette moduler, navngive det som clientJS eller et andet navn, du foretrækker, og til sidst konvertere det til AMD/RequireJS ved hjælp af browserify.

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

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

Nu skal vi for at konvertere ovenstående kode til at være AMD-kompatibel, med andre ord til at indlæse moduler asynkront, gøre det via følgende kommandolinjeargumenter:

browserify client.js -o amdmodule.js

Du kan tildele et hvilket som helst navn, du foretrækker, til at være klient. Det skal ikke altid være client.js, men client.js er også at foretrække. Husk, at det blot er en fil. Desuden kan du se mere konfiguration om browserify på http://browserify.org/.

Afsluttende:

Slutteligt skal du være opmærksom på, at ikke alle node.JS-moduler kan konverteres til at fungere effektivt i browseren. De, der er afhængige af funktioner, der er tilgængelige på serversiden, vil slet ikke fungere i browseren.

Jeg har netop introduceret AMD/RequireJS som en løsning, der tillader asynkron indlæsning af moduler i browseren, hvilket anses for at være en god praksis. Asynkron indlæsning af moduler er meget hurtigere og mere pålidelig end at bruge CommonJS i browseren.