Apprenez les spécifications du module de node(1) de 0 à 1

Avant d'expliquer les concepts de CommonJS, AMD et CMD, nous comprenons d'abord la modularité de js. La modularisation, comme son nom l'indique, consiste à décomposer le projet selon des fonctions ou une autre logique. Chaque partie ne gère qu'une seule fonction pour découpler les fonctions afin de faciliter le développement et la maintenance futurs. Ensuite, la modularisation doit avoir les capacités suivantes pour diviser et assembler des modules :

1. Définir les modules encapsulés

2. Définir la dépendance ; du nouveau module sur d'autres modules ;

3. peut prendre en charge l'introduction d'autres modules

Ensuite, un ensemble de spécifications est nécessaire. Des lignes directrices ont été utilisées ; pour définir ces capacités, sont apparus CommonJS, AMD, CMD, etc.

1. CommonJS

CommonJS s'appelait à l'origine ServerJS, qui est la spécification de js côté serveur. C'est la spécification utilisée par node. Selon la spécification CommonJS, un seul fichier est un module, require est utilisé pour charger un module et exports est utilisé pour exposer des méthodes ou des propriétés du module à l'extérieur.

Par exemple :

// hello.jsfunction say(username){    console.log( 'hello, '+username );
}

exports.say = say;

=============

// main.jsvar person = require('./hello');

person.say('wenzi'); // hello, wenziperson.say('师少兵'); // hello, 师少兵person.say('NUC'); // hello, NUC

En même temps, l'instruction require peut être écrite n'importe où dans le fichier, à condition qu'elle soit utilisée avant la référence, elle n'a pas besoin d'être écrite au début du fichier. Cependant, afin de faciliter la lecture du code et de voir intuitivement quels modules sont actuellement référencés, il est préférable de le mettre au début du fichier.

La différence entre exports et module.exports

Certaines personnes ont peut-être vu utiliser directement exports, et d'autres utiliser module.exports. Voici une brève explication de la différence entre les deux.

Prenons un exemple simple :

var a = {name:'wenzi'};var b = a;console.log(a); // {name: "wenzi"}console.log(b); // {name: "wenzi"}

Les résultats de sortie de a et b sont les mêmes. Maintenant, je change la valeur de name dans b :

b.name = 'shaobing';console.log(a); // {name: "shaobing"}console.log(b); // {name: "shaobing"}

Les résultats de sortie de a et b ont changé. Je redéclare b :

var b = {name:'师少兵'};console.log(a); // {name: "shaobing"}console.log(b); // {name: "师少兵"}

Ces trois exemples génèrent trois résultats :

1. déclare un objet, et attribue a à b, puis a et b génèrent le même résultat ;

2. change le nom dans b, puis le nom dans a change également

3. Redéclare l'objet b ; , alors le nom dans a ne change pas avec b

Explication : a est un objet, b est la référence à a, c'est-à-dire a et b point dans la même mémoire, donc la sortie en 1 est la même. Lorsque b est modifié, c'est-à-dire que le contenu de a et b pointant vers la même adresse mémoire a changé, a sera également reflété, donc la sortie du deuxième exemple sera la même. Lorsque b est écrasé, b pointe vers une nouvelle mémoire et a pointe toujours vers la mémoire d'origine, donc la sortie finale sera différente.

Ensuite, vous pouvez introduire exports et module.exports à ce moment :

1. La valeur initiale de module.exports est un objet vide {}

2. exports est une référence à module.exports

3. require() renvoie module.exports au lieu de exports

Si module.exports a un nouveau pointeur, les exportations ne seront pas valides ; si module.exports n'a pas changé, exportez-le simplement directement.

2. AMD et RequireJS

En parlant d'AMD, je dois dire RequireJS qu'AMD est devenu indépendant de la communauté CommonJS et est devenu la seule communauté AMD. La popularité d'AMD est en grande partie due. Il s'appuie également sur la promotion des auteurs RequireJS.

Dans la spécification AMD, le format de module recommandé par défaut est :

// hello.js// 将需要引入的模块全部写入到数组中，然后传递参数进行调用define(['a', 'b'], function(a, ,b){    // do something    return{
        hello : function(username){            console.log( 'hello, '+username );
        }
    }
})

==========

// main.jsdefine(['./hello'], function(h){
    h.hello('wenzi');
})

En d'autres termes, dans AMD, les modules doivent être définis à l'aide de define et les dépendances sont transmises via les paramètres de fonction. L'un des avantages de ceci est que toutes les dépendances peuvent être vues d'un seul coup d'œil.

3. CMD et seajs

La spécification CMD a été proposée par le célèbre Dieu Yubo en Chine. La seule chose à faire est 就近依赖. à cet endroitrequire. SeaJS utilise la spécification CMD :

// hello.jsdefine(function(require, exports, module){    var a = require('a');    // do a    var b = require( 'b' );    // do b    module.exports.hello = hello; // 对外输出hello})

Vous pouvez également voir la différence entre AMD et CMD à partir d'ici :

AMD doit généralement introduire toutes les dépendances en même temps, puis les transmettre via des paramètres tandis que CMD ne les introduit qu'en cas de besoin

Cependant, AMD prend également en charge les formats d'importation tels que CMD, mais l'exécution interne est toujours basée sur la logique d'AMD.

4. Résumé

Cet article présente les différences et les connexions pertinentes entre les spécifications CommonJS, AMD et CMD :

1. CommonJS : Chaque fichier est un module et n'a pas besoin d'être défini. Le nœud utilise cette spécification

2. AMD : utilisez Définir pour définir un module et faites attention à

   en fonction de celui-ci ; à l'avance;

3. CMD : utilisez Définir pour définir les modules et dépendre de

   à proximité

Ensuite, nous va commencer L'apprentissage du nœud est officiellement commencé.