A CommonJS és az AMD/RequireJS összehasonlítása

Bevezetés

Az olyan webszerverekkel ellentétben, mint az Apache és a Microsoft IIS, amelyek mindkettő előre konfigurált, a node.js egészen más. A node.js segítségével a fejlesztők a semmiből építenek webkiszolgálókat. A fejlesztő kódolási készségeitől elvárják a webkiszolgáló védelmét. Így a Node.js különbözik az Apache-tól és a többitől.

Ebben a cikkben a node.js két fő rendszermoduljára – AMD és Common.js – fogunk összpontosítani. Mielőtt összehasonlítanánk a kettőt, meg kell beszélnünk a két rendszermodul közötti különbségeket. Két irányadó kérdés, amely segít a kettő összehasonlításában: melyik gyorsabb a modulok betöltésekor a böngészőben vagy a böngészőből, és hogyan lehet az egyik rendszermodult úgy átalakítani, hogy a másik rendszermodul bizonyos tulajdonságait örökölje.

Ez a cikk nem a node.js amd javascript alapjaira fog összpontosítani. Nem fog olyan témákkal foglalkozni, mint például “hogyan telepítsük a node.js-t”, “hogyan használjuk az npm-et vagy a nave-et a csomagok telepítéséhez”, vagy “a node.js különböző verziói a különböző projektekhez”. Célunk, hogy feloldjuk az AMD és a Common.js közötti zavart. Ezért könnyedén kiemeljük a node.js alapmoduljait, néhány függvényt és változót, és végül a figyelmünket az AMD-re és a Common.js-re irányítjuk, valamint arra, hogyan alakíthatjuk át az egyik rendszermodult, hogy a böngészőben gyorsabban betöltődjenek a modulok.

Core, File és külső node modulok

A node.js-ben három fő fontos modul van; Core, file és külső node modulok. Kezdjük először a file modullal, mert az könnyebben megfogható.

• File modul:
  A másik két modullal ellentétben a file modell egy relatív elérési útvonalon alapuló modell. Hogy miért? Tegyük fel, hogy a következő szintaxissal exportálnánk egy modult:

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

A modulok betöltésének vagy fájlba importálásának módja teljesen eltér a core és az external_node modulokétól; ezért a másik kettőt nem relatív alapú moduloknak is nevezik.

Figyelem: a node.js-ben a modulok/fájlok exportálásának sokféle módja létezik. Az anonim függvény egy másik módja a modul exportálásának egy fájlból.

• Magmodulok:
  A következő modulok, amelyek a node.js három fő modulját tartalmazzák, a magmodulok. A core modulok nem relatív alapú modulok. Nagyon különböznek a fájlmoduloktól, különösen akkor, ha modulokat kérünk (vagy importálunk) fájlba.

Ha például a node.js-ben fogyasztanánk a path modult, amely az OS-specifikusan javítja a kötőjeleket, gondoskodik a . és .. az elérési útvonalban, és eltávolítja a duplikált kötőjeleket is, akkor nem vennénk fel a relatív elérési utat:

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

• external_node modulok:
  Ezek a modulok valahol a core és a fájlalapú modulok között helyezkednek el. Az external_node modulok eléggé hasonlítanak a fájlalapúakhoz, különösen akkor, amikor egy modult exportálunk.

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

A modulok betöltésekor azonban már egészen másképp viselkednek.

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

A node.js ezen kívül néhány fontos globális hasznos funkciót is biztosít, amelyeket nem fogunk részletesen tárgyalni. timer,console, _filename és_dirname, valamint a process mind példák a node.js fontos globáljaira. A _filename és _dirname például minden fájlban elérhető, és hozzáférést biztosít az aktuális modul teljes elérési útvonalához és könyvtárához.

Most, hogy röviden megértettük a modulokat a node.js-ben, térjünk rá a fő szempontra, ahol megkülönböztetjük a CommonJS és AMD modulokat. Foglalkozni fogunk a “miért olyan lassú a Common.js a modulok betöltése a böngészőből” és “hogyan tudjuk átalakítani a browserify segítségével, hogy örökölje az AMD és a Require.js bizonyos tulajdonságait” problémákkal. .

A CommonJS és az AMD bemutatása

 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. 

Lássuk például, hogyan töltődik be a két modul a szerveroldali környezetben:

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

A fenti példát nézve, szerveroldalon jó gyakorlatnak számít, ha az egyik modul betöltődik, miközben a másik modul egy másik modul elemzésére vár.

Más szavakkal, amikor a foo modul betöltődik, a bar nem lesz elemezve vagy feldolgozva, amíg a foo nem töltődik le teljesen. Még a szerver sem biztos, hogy tud a bar modulról, amíg nem végzett a foo modullal.

Az azonos modulrendszer használata a böngészőben nem tekinthető jó ötletnek, mert minden modulrendszernek HTTP-kérést kellene indítania a szerver felé. Ez szerverkörnyezetben sokkal kevésbé hatékony és kevésbé megbízható. A kliens oldalon rontja a felhasználói élményt. Ezt a problémát a modulok aszinkron betöltésével lehetne megoldani.

Az AMD itt lép a képbe. Az AMD, más néven aszinkron moduldefiníció, azért került bevezetésre, hogy támogassa a modulok aszinkron betöltését a böngészőben –
ez végül megoldja a modulok betöltésének lassúságát a böngészőben. Az “aszinkron” jelentésével összhangban a modulok különböző időpontokban indulnak el.

Az AMD-ben ahhoz, hogy valamit exportáljunk egy fájlba, egyszerűen be kell építenünk egy visszahívási függvényt, és vissza kell adnunk egy definiált visszahívási függvényből. Íme egy példa:

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

A node.JS-ben található export változó szintaxisához hasonlóan a define függvény is elfogad egy speciális argumentumot, az exports-t, ami nagyon hasonló a node.JS-ben találhatóhoz.

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

Hogy lehetővé tegyük két modul betöltését a böngészőben, a RequireJS-t le kell töltenünk és telepítenünk kell. Ne feledjük, ez csak egy lehetőség, amely megakadályozza, hogy a fejlesztők node.JS kódot használjanak a böngészőben.]

Miért van szükségünk RequireJS-re, hogy az aszinkron moduldefiníción keresztül tudjunk modulokat betölteni?
Itt az ok: mert a Define függvény, amely az alábbi kód része (amely megmutatja nekünk, hogyan tudunk egynél több modult betölteni a böngészőben az AMD-n keresztül), nem natív a böngészőben. Ezért a legjobb megoldás, ha egy harmadik féltől származó könyvtárból érjük el. A RequireJS egyszerűen egy javascript fájl, amelyet beillesztünk a projektünkbe.

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

Hogyan konvertáljuk a node.js-t böngésző kóddá:

Most nézzük meg, hogyan konvertálhatjuk a CommonJS-t, hogy kompatibilis legyen az AMD/RequireJS-sel a browserify segítségével. A CommonJS átalakítása a browserify segítségével lehetővé teszi, hogy a node.js az AMD/RequireJS-hez hasonlóan töltse be a modulokat a böngészőben.

Telepítsük a browserify-t az alábbi kód segítségével. Kérjük, győződjünk meg róla, hogy a telepítés során csatlakoztatva vagyunk az internethez. A kötőjeles g egyszerűen globálisat jelent.

npm install –g browserify

Modulokat hozhatsz létre, nevezd el clientJS-nek vagy bármilyen más névnek, és végül a browserify segítségével alakítsd át AMD/RequireJS-re.

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

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

Most, hogy a fenti kódot AMD-kompatibilissé alakítsuk, más szóval, hogy a modulokat aszinkron módon töltsük be, ezt a következő parancssori argumentumokkal kell megtennünk:

browserify client.js -o amdmodule.js

A kliensnek tetszőleges nevet adhatunk. Nem kell, hogy mindig a client.js legyen, de a client.js is előnyös. Ne feledd, hogy ez csak egy fájl. Továbbá, a browserify-ról további konfigurációt nézhetsz meg a http://browserify.org/.

Wrapping up:

Végezetül meg kell jegyezned, hogy nem minden node.JS modul alakítható át úgy, hogy hatékonyan működjön a böngészőben. Azok, amelyek a szerveroldalon elérhető funkcióktól függenek, egyáltalán nem fognak működni a böngészőben.

Az AMD/RequireJS-t most mutattam be, mint olyan megoldást, amely lehetővé teszi a modulok aszinkron betöltését a böngészőben, ami jó gyakorlatnak számít. A modulok aszinkron betöltése sokkal gyorsabb és megbízhatóbb, mint a CommonJS használata a böngészőben.