Download de code: learnamd.js
De Asynchronous Module Definition API specificeert een mechanisme om JavaScript modules the definiëren zodat de module en dependencies (afhankelijkheden) asynchroon geladen kunnen worden. Dit is vooral erg geschikt voor de browseromgeving, waar het synchroon laden van modules zorgt voor problemen qua prestatie, gebruiksvriendelijkheid, debugging en cross-domain toegangsproblemen.
// De basis AMD API bestaat uit niks meer dan twee methodes: `define` en `require`
// and gaat vooral over de definitie en gebruik van modules:
// `define(id?, dependencies?, factory)` definieert een module
// `require(dependencies, callback)` importeert een set van dependencies en
// gebruikt ze in de gegeven callback
// Laten we starten met het gebruiken van define om een nieuwe module (met naam)
// te creëeren, welke geen dependencies heeft. Dit doen we door een naam
// en een zogeheten factory functie door te geven aan define:
define('awesomeAMD', function(){
var isAMDAwesome = function(){
return true;
};
// De return waarde van een module's factory functie is
// wat andere modules of require calls ontvangen wanneer
// ze onze `awesomeAMD` module requiren.
// De geëxporteerde waarde kan van alles zijn: (constructor) functies,
// objecten, primitives, zelfs undefined (hoewel dat niet veel nut heeft).
return isAMDAwesome;
});
// We gaan nu een andere module defineren die afhankelijk is van onze
// `awesomeAMD` module. Merk hierbij op dat er nu een extra functieargument
// is die de dependencies van onze module defineert:
define('schreewlelijk', ['awesomeAMD'], function(awesomeAMD){
// dependencies worden naar de factory's functieargumenten
// gestuurd in de volgorde waarin ze gespecificeert zijn
var vertelIedereen = function(){
if (awesomeAMD()){
alert('Dit is zOoOo cool!');
} else {
alert('Vrij saai, niet?');
}
};
return vertelIedereen;
});
// Nu we weten hoe we define moeten gebruiken, kunnen we require gebruiken
// om ons programma mee te starten. De vorm van `require` is
// `(arrayVanDependencies, callback)`.
require(['schreeuwlelijk'], function(schreewlelijk){
schreeuwlelijk();
});
// Om deze tutorial code uit te laten voeren, gaan we hier een vrij basic
// (niet-asynchrone) versie van AMD implementeren:
function define(naam, deps, factory){
// merk op hoe modules zonder dependencies worden afgehandeld
define[naam] = require(factory ? deps : [], factory || deps);
}
function require(deps, callback){
var args = [];
// we halen eerst alle dependecies op die nodig zijn
// om require aan te roepen
for (var i = 0; i < deps.length; i++){
args[i] = define[deps[i]];
}
// voldoe aan alle dependencies van de callback
return callback.apply(null, args);
}
// je kan deze code hier in actie zien (Engels): http://jsfiddle.net/qap949pd/
In contrast met het voorbeeld uit de introductie, implementeert require.js
(de meest populaire AMD library) de A in AMD. Dit maakt het mogelijk
om je modules en hun dependencies asynchroon in the laden via XHR:
/* file: app/main.js */
require(['modules/someClass'], function(SomeClass){
// de callback word uitgesteld tot de dependency geladen is
var things = new SomeClass();
});
console.log('Dus, hier wachten we!'); // dit wordt als eerste uitgevoerd
De afspraak is dat je over het algemeen één module in één bestand opslaat.
require.js kan module-namen achterhalen gebaseerd op de bestandslocatie,
dus je hoeft je module geen naam te geven. Je kan simpelweg aan ze referen
door hun locatie te gebruiken.
In het voorbeeld nemen we aan dat someClass aanwezig is in de modules map,
relatief ten opzichte van de baseUrl uit je configuratie.
Dit betekent dat we someClass kunnen defineren zonder een module-id te specificeren:
/* file: app/modules/someClass.js */
define(['daos/things', 'modules/someHelpers'], function(thingsDao, helpers){
// definitie van de module gebeurt, natuurlijk, ook asynchroon
function SomeClass(){
this.method = function(){/**/};
// ...
}
return SomeClass;
});
Gebruik requirejs.config(configObj) om het gedrag van de standaard mapping
aan te passen in je main.js:
/* file: main.js */
requirejs.config({
baseUrl : 'app',
paths : {
// je kan ook modules uit andere locatie inladen
jquery : '//ajax.googleapis.com/ajax/libs/jquery/1.11.1/jquery.min',
coolLibUitBower : '../bower_components/cool-lib/coollib'
}
});
require(['jquery', 'coolLibUitBower', 'modules/someHelpers'], function($, coolLib, helpers){
// een `main` bestand moet require minstens eenmaal aanroepen,
// anders zal er geen code uitgevoerd worden
coolLib.doFancyDingenMet(helpers.transform($('#foo')));
});
Op require.js gebaseerde apps hebben vaak een enkel beginpunt (main.js)
welke toegevoegd wordt aan de require.js script tag als een data-attribuut.
Deze zal automisch geladen en uitgevoerd worden als de pagina laadt:
<!DOCTYPE html>
<html>
<head>
<title>Honder script tags? Nooi meer!</title>
</head>
<body>
<script src="require.js" data-main="app/main"></script>
</body>
</html>
Veel mensen geven er de voorkeur aan om AMD te gebruiken tijdens de ontwikkelfase om code op een gezonde manier te organiseren maar willen nog steeds een enkel scriptbestand gebruiken in productie in plaats van honderderen XHR verzoeken uit te voeren als de pagina laadt.
require.js wordt geleverd met een script genaamd r.js (die je waarschijnlijk
uitvoert in node.js, hoewel Rhino ook ondersteund wordt) welke de
dependency book van je project analyseert en een enkel bestand bouwt met daarin
al je module (juist genaamd), geminificeerd en klaar voor productie.
Instaleren met npm:
$ npm install requirejs -g
Nu kun je het een configuratiebestand voeden:
$ r.js -o app.build.js
Voor ons bovenstaande voorbeeld zou de configuratie er zo uit kunnen zien:
/* file : app.build.js */
({
name : 'main', // naam van het beginpunt
out : 'main-built.js', // naam van het bestand waar de output naar geschreven wordt
baseUrl : 'app',
paths : {
// `empty:` verteld r.js dat dee nog steeds geladen moet worden van de CDN,
// gebruik makend van de locatie gespecificeert in `main.js`
jquery : 'empty:',
coolLibUitBower : '../bower_components/cool-lib/coollib'
}
})
Verwissel simpelweg data-main om het gebouwde bestand te gebruiken in productie:
<script src="require.js" data-main="app/main-built"></script>
Een erg gedetaileerd overzicht van bouwopties is beschikbar in de GitHub repo (Engels).
Hieronder vind je nog meer informatie over AMD (Engels).
Heb je een suggestie of verbetering? Maak een ticket aan op de GitHub Repo, of maak zelf een pull request!
Originele versie van Frederik Ring, en geüpdatet door 1 contributor(s).