Das Laden und Ausführen des Moduls werden in node.js eingewickelt, so dass die Variablen in der Moduldatei in einem Verschluss stehen und keine globalen Variablen verschmutzen und mit anderen in Konflikt stehen.
Front-End-Module sind in der Regel diejenigen, die wir Entwickler Modulcode in einen Schluss legen, um Konflikte mit anderen zu vermeiden.
So können wir die Module, die Node.js und Front-End gemeinsam sind, auf die Implementierung von Unscore.js verweisen. Es ist ein Funktionsfunktionsmodul, das Node.js und Front-End gemeinsam ist. Überprüfen Sie den Code:
Die Codekopie lautet wie folgt:
// Erstellen Sie einen sicheren Verweis auf das Unterstrich -Objekt für die Verwendung unten.
var _ = function (obj) {
if (obj Instance von _) return obj;
if (! (diese Instanz von _)) gibt neu _ (obj) zurück;
this._wraded = obj;
};
// das Unterstrich -Objekt für ** node.js ** mit exportieren, mit
// Rückwärtskompatibilität für die alte `Request ()` api. Wenn wir drin sind
// Der Browser fügen Sie `_` als globales Objekt über eine String -Kennung hinzu.
// für den Verschluss Compiler "Advanced" -Modus.
if (typeof exports! == 'undefined') {
if (typeof modul! == 'undefined' && module.exports) {
exports = module.exports = _;
}
exports._ = _;
} anders {
root._ = _;
}
Entscheiden Sie sich, Exporte lokaler Variable zuzuweisen, indem Sie beurteilen, ob Exporte vorhanden sind. Dies ist rückwärts kompatibel mit der alten Request () API. Wenn im Browser eine String -Kennung "_" als globales Objekt verwendet wird; Der vollständige Verschluss ist wie folgt:
Die Codekopie lautet wie folgt:
(function () {
// Basis -Setup
// ----------------
// Festlegen des Stammobjekts, "Fenster" im Browser oder "Exportieren" auf dem Server.
var root = this;
// Erstellen Sie einen sicheren Verweis auf das Unterstrich -Objekt für die Verwendung unten.
var _ = function (obj) {
if (obj Instance von _) return obj;
if (! (diese Instanz von _)) gibt neu _ (obj) zurück;
this._wraded = obj;
};
// das Unterstrich -Objekt für ** node.js ** mit exportieren, mit
// Rückwärtskompatibilität für die alte `Request ()` api. Wenn wir drin sind
// Der Browser fügen Sie `_` als globales Objekt über eine String -Kennung hinzu.
// für den Verschluss Compiler "Advanced" -Modus.
if (typeof exports! == 'undefined') {
if (typeof modul! == 'undefined' && module.exports) {
exports = module.exports = _;
}
exports._ = _;
} anders {
root._ = _;
}
}). Call (this);
Ein Verschluss wird durch Funktionsdefinition erstellt. Aufruf (dies) wird die Funktion unter diesem Objekt aufrufen, um interne Variablen zu vermeiden, die in den globalen Bereich kontaminieren. Im Browser verweist dies auf ein globales Objekt (Fensterobjekt), wobei die Variable "_" dem globalen Objekt "root._" für externe Aufrufe zugewiesen wird.
LO-DASH, ähnlich wie unterstrich.js, verwendet auch eine ähnliche Lösung, ist jedoch mit dem Lademodulverbot vereinbar:
Die Codekopie lautet wie folgt:
; (function () {
/** als sichere Referenz für `undefined` in Pre ES5 -Umgebungen*/////
var undefiniert;
/** verwendet, um festzustellen, ob Werte vom Sprachtypobjekt*/sind
var ObjectTypes = {
'boolean': falsch,
'Funktion': wahr,
'Objekt': wahr,
'Nummer': Falsch,
'String': Falsch,
'undefiniert': Falsch
};
/** als Verweis auf das globale Objekt*/verwendet
var root = (ObjectTtypes [TypeOF -Fenster] && Fenster) || Das;
/** freie Variable erkennen `exports`*/
var FreeExports = ObjectTtypes [TypeOf Exports] && exports &&! exports.nodetype && exports;
/** freie Variable `modul`*///
var freemodule = ObjectTypes [TypeOF -Modul] && Modul &&! modul.nodetype && modul;
/** Erkennen Sie die beliebte CommonJS -Erweiterung `module.exports`*/
var moduleexports = freemodule && freemodule.exports === FreeExports && FreeExports;
/*------------------------------------------------------------------*/////////////
// lo-cash entlarven
var _ = RunContext ();
// Einige AMD -Optimierer erstellen wie R.Js wie die folgenden Bedingungenmuster:
if (typeof define == 'function' && typeof define.amd == 'Objekt' && define.amd) {
// LO-Dash dem globale Objekt aussetzen, auch wenn ein AMD-Loader in vorhanden ist
// case lo-----13 wurde von einem Drittanbieter-Skript injiziert und war nicht beabsichtigt, es zu sein
// als Modul geladen. Die globale Zuordnung kann im Lo-Dash zurückgekehrt werden
// Modul durch seine `noconflict ()` -Methode.
root._ = _;
// definieren als anonymes Modul, also kann es durch Pfadzuordnung sein
// als "Unterstrich" -Modul bezeichnet
Define (function () {
zurückkehren _;
});
}
// nach "exportieren" nach `define`" falls ein Build -Optimierer ein "Exporte" -Objekt hinzufügt
sonst if (FreeExports && Freemodule) {
// in node.js oder ringojs
if (moduleexports) {
(freemodule.exports = _) ._ = _;
}
// in Narwhal oder Rhino -Require
anders {
FreeExports._ = _;
}
}
anders {
// in einem Browser oder Rhino
root._ = _;
}
} .call (this));
Schauen wir uns den Hauptcode des Moments an.js Kapselung Schließung:
Die Codekopie lautet wie folgt:
(Funktion (undefiniert) {
var moment;
// nach NodeJs prüfen
var hasmodule = (TypeOF -Modul! == 'undefined' && module.exports);
/****************************************************************
Moment aufdecken
*******************************************
Funktion makeGlobal (deprescate) {
var gewarnt = false, local_moment = moment;
/ *Global Ender: Falsch */
if (typeof ender! == 'undefined') {
zurückkehren;
}
// hier, `this` bedeutet" Fenster "im Browser oder" Global "auf dem Server
// `moment` als globales Objekt über eine String -Kennung hinzufügen,
// für den Verschluss Compiler "Advanced" -Modus
if (deprescate) {
this.moment = function () {
if (! gewarnt && console && console.warn) {
gewarnt = wahr;
console.warn (
"Zugriff auf den Moment durch den globalen Bereich ist" + +
"veraltet und wird in einem kommenden" + entfernt " +
"freigeben.");
}
return local_moment.apply (null, argumente);
};
} anders {
dieses ['moment'] = moment;
}
}
// CommonJS -Modul ist definiert
if (HasModule) {
module.exports = moment;
MakeGlobal (wahr);
} else if (typeof define === "function" && define.amd) {
Define ("moment", function (erfordern, exportiert, modul) {
if (module.config (). noglobal! == true) {
// Wenn der Benutzer Noglobal zur Verfügung gestellt hat, ist er sich der globalen Bekanntheit bewusst
makeGlobal (modul.config (). noglobal === undefined);
}
Rückkehrmoment;
});
} anders {
makeGlobal ();
}
}). Call (this);
Wie aus den obigen Beispielen ersichtlich ist, kann bei der Einkapselung von Modulen, die bei Node.js und Front-End gemeinsam sind, die folgende Logik verwendet werden:
Die Codekopie lautet wie folgt:
if (typeof exports! == "undefined") {
Exporte. ** = **;
} anders {
Dies. ** = **;
}
Das heißt, wenn das Exportobjekt vorhanden ist, wird die lokale Variable auf das Exportobjekt geladen, und wenn es nicht existiert, wird sie auf das globale Objekt geladen. Wenn die Kompatibilität der ADM -Spezifikation hinzugefügt wird, fügen Sie ein weiteres Urteil hinzu, um zu beurteilen:
Kopieren Sie den Code -Code wie folgt: if (typeof define === "function" && define.amd) {}