Le chargement et l'exécution du module sont enveloppés dans Node.js afin que les variables du fichier de module soient dans une fermeture et ne pollueront pas les variables globales et entrent en conflit avec les autres.
Les modules frontaux sont généralement ceux que les développeurs placent du code du module dans une fermeture pour éviter les conflits avec les autres.
Comment encapsuler les modules communs à Node.js et frontal, nous pouvons nous référer à la mise en œuvre de sous-ore.js. Il s'agit d'un module de fonction fonctionnel commun à Node.js et frontal. Vérifiez le code:
La copie de code est la suivante:
// Créez une référence sûre à l'objet de soulignement à utiliser ci-dessous.
var _ = fonction (obj) {
if (obj instanceof _) return obj;
if (! (Cette instance _)) renvoie nouveau _ (obj);
this._wrapy = obj;
};
// Exporter l'objet de trait de trait pour ** node.js **, avec
// en arrière-compatibilité pour l'ancienne API `requis () '. Si nous sommes dans
// le navigateur, ajoutez `_` en tant qu'objet global via un identifiant de chaîne,
// pour le compilateur de fermeture en mode "avancé".
if (typeof exportts! == 'Undefined') {
if (typeof module! == 'Undefined' && module.exports) {
exports = module.exports = _;
}
export._ = _;
} autre {
root._ = _;
}
Décidez d'attribuer une variable locale aux exportations en jugeant si les exportations existent, ce qui est en arrière compatible avec l'ancienne API requis (). Si dans le navigateur, un identifiant de chaîne "_" est utilisé comme objet global; La fermeture complète est la suivante:
La copie de code est la suivante:
(fonction() {
// Configuration de base
// ----------------
// Établissez l'objet racine, «Window» dans le navigateur, ou «Exports» sur le serveur.
var root = this;
// Créez une référence sûre à l'objet de soulignement à utiliser ci-dessous.
var _ = fonction (obj) {
if (obj instanceof _) return obj;
if (! (Cette instance _)) renvoie nouveau _ (obj);
this._wrapy = obj;
};
// Exporter l'objet de trait de trait pour ** node.js **, avec
// en arrière-compatibilité pour l'ancienne API `requis () '. Si nous sommes dans
// le navigateur, ajoutez `_` en tant qu'objet global via un identifiant de chaîne,
// pour le compilateur de fermeture en mode "avancé".
if (typeof exportts! == 'Undefined') {
if (typeof module! == 'Undefined' && module.exports) {
exports = module.exports = _;
}
export._ = _;
} autre {
root._ = _;
}
}). Appelez (ceci);
Une fermeture est construite par la définition de la fonction, et l'appel (ceci) consiste à appeler la fonction sous cet objet pour éviter les variables internes contaminant la portée globale. Dans le navigateur, cela pointe vers un objet global (objet Window), attribuant la variable "_" à l'objet global "root._" pour les appels externes.
Lo-Dash, similaire à sous-traitant.js, utilise également une solution similaire, mais est compatible avec le chargement du module AMD:
La copie de code est la suivante:
;(fonction() {
/ ** Utilisé comme référence sûre pour «Undefined» dans les environnements pré es5 * /
var indéfini;
/ ** Utilisé pour déterminer si les valeurs sont de l'objet de type de langue * /
var ObjectTypes = {
'booléen': faux,
'fonction': vrai,
'objet': vrai,
'nombre': false,
'String': false,
«Undefined»: faux
};
/ ** utilisé comme référence à l'objet global * /
var root = (ObjectTypes [Typeof Window] && fenêtre) || ce;
/ ** détecter la variable gratuite `exportts` * /
var freeExports = ObjectTypes [typeof exports] && exports &&! exports.nodeType && exports;
/ ** détecter la variable gratuite `module` * /
var freemodule = ObjectTypes [module typeof] && module &&! module.nodeType && module;
/ ** détecter l'extension CommonJS populaire `module.exports` * /
var moduleExports = freemodule && freemodule.exports === freeExports && freeExports;
/ * -------------------------------------------------------------------------- * /
// Expose Lo-Dash
var _ = runinConText ();
// Certains optimisateurs de construction AMD, comme R.JS, vérifient les modèles de condition comme les suivants:
if (typeof define == 'function' && typeof define.amd == 'objet' && define.amd) {
// exposer Lo-Dash à l'objet global même lorsqu'un chargeur AMD est présent
// Case Lo-Dash a été injecté par un script tiers et non destiné à être
// chargé en tant que module. L'affectation globale peut être retournée dans le lo-dash
// Module par sa méthode `noconflict ()`.
root._ = _;
// définir comme un module anonyme, donc, à travers la cartographie du chemin, il peut être
// Référencé comme le module "Contrôle"
définir (function () {
retour _;
});
}
// Vérifiez les «exportations» après «définir» au cas où un optimiseur de construction ajoute un objet «exportations»
else if (freeExports && freemodule) {
// dans node.js ou ringojs
if (moduleExports) {
(freemodule.exports = _) ._ = _;
}
// dans le narhal ou le rhinocéros
autre {
freeExports._ = _;
}
}
autre {
// dans un navigateur ou un rhinocéros
root._ = _;
}
} .call (this));
Jetons un coup d'œil au code principal du moment.js fermeture de l'encapsulation:
La copie de code est la suivante:
(fonction (indéfinie) {
Var Moment;
// Vérifiez les nodejs
var hasmodule = (typeof module! == 'Undefined' && module.exports);
/ ********************************************************
Moment d'exposition
********************************************* /
fonction makeGlobal (dépréciation) {
var averti = false, local_moment = Moment;
/ * Global Ender: False * /
if (typeof ender! == 'Undefined') {
retour;
}
// Ici, «cela» signifie «fenêtre» dans le navigateur, ou «global» sur le serveur
// ajouter `Moment` en tant qu'objet global via un identifiant de chaîne,
// pour le compilateur de fermeture mode "avancé"
if (déprécié) {
this.moment = function () {
if (! averti && console && console.warn) {
averti = true;
console.warn (
"Le moment accéder à la portée globale est" +
"déprécié, et sera supprimé dans un prochain" +
"libérer.");
}
return local_moment.apply (null, arguments);
};
} autre {
ce ['moment'] = moment;
}
}
// Le module CommonJS est défini
if (Hasmodule) {
module.exports = Moment;
MakeGlobal (vrai);
} else if (typeof define === "function" && define.amd) {
définir ("moment", fonction (require, exportations, module) {
if (module.config (). noglobal! == true) {
// Si l'utilisateur a fourni Noglobal, il est au courant de Global
MakeGlobal (module.config (). noglobal === Undefined);
}
Moment de retour;
});
} autre {
MakeGlobal ();
}
}). Appelez (ceci);
Comme on peut le voir à partir des exemples ci-dessus, lors de l'encapsulation des modules communs à Node.js et frontal, la logique suivante peut être utilisée:
La copie de code est la suivante:
if (typeof exportts! == "Undefined") {
exportations. ** = **;
} autre {
this. ** = **;
}
Autrement dit, si l'objet d'exportation existe, la variable locale est chargée sur l'objet Exports, et s'il n'existe pas, il est chargé sur l'objet global. Si la compatibilité de la spécification ADM est ajoutée, ajoutez une phrase supplémentaire pour juger:
Copiez le code de code comme suit: if (typeof define === "fonction" && define.amd) {}