La carga y la ejecución del módulo están envueltas en Node.js para que las variables en el archivo del módulo estén en un cierre y no contaminen variables globales y conflican con los demás.
Los módulos frontales suelen ser los que los desarrolladores colocamos el código del módulo en un cierre para evitar conflictos con los demás.
Cómo encapsular los módulos que son comunes a Node.js y front-end, podemos referirnos a la implementación de underscore.js. Es un módulo de función funcional que es común a Node.js y front-end. Verifique el código:
La copia del código es la siguiente:
// Cree una referencia segura al objeto bajo para usar a continuación.
var _ = function (obj) {
if (obj instancia de _) return obj;
if (! (esta instancia de _)) devuelve nuevo _ (obj);
this._wrapped = obj;
};
// Exportar el objeto de subscorte para ** node.js **, con
// Compatibilidad hacia atrás para la antigua API `request ()`. Si estamos en
// El navegador, agregue `_` como objeto global a través de un identificador de cadena,
// para el modo "avanzado" del compilador de cierre.
if (typeof exports! == 'indefinido') {
if (typeof module! == 'Undefined' && Module.exports) {
exports = módulo.exports = _;
}
exports._ = _;
} demás {
root._ = _;
}
Decide asignar variable local_ a las exportaciones juzgando si existen exportaciones, que es compatible con la API requerir () anterior. Si en el navegador, un identificador de cadena "_" se usa como un objeto global; El cierre completo es el siguiente:
La copia del código es la siguiente:
(función() {
// Configuración de línea de base
// ----------------
// Establecer el objeto raíz, `Window` en el navegador o` exportaciones 'en el servidor.
var root = this;
// Cree una referencia segura al objeto bajo para usar a continuación.
var _ = function (obj) {
if (obj instancia de _) return obj;
if (! (esta instancia de _)) devuelve nuevo _ (obj);
this._wrapped = obj;
};
// Exportar el objeto de subscorte para ** node.js **, con
// Compatibilidad hacia atrás para la antigua API `request ()`. Si estamos en
// El navegador, agregue `_` como objeto global a través de un identificador de cadena,
// para el modo "avanzado" del compilador de cierre.
if (typeof exports! == 'indefinido') {
if (typeof module! == 'Undefined' && Module.exports) {
exports = módulo.exports = _;
}
exports._ = _;
} demás {
root._ = _;
}
}). Llame (esto);
Se crea un cierre a través de la definición de función, y la llamada (esto) es llamar a la función debajo de este objeto para evitar variables internas que contaminen en el alcance global. En el navegador, esto apunta a un objeto global (objeto de ventana), asignando la variable "_" al objeto global "root._" para llamadas externas.
LO-Dash, similar a Underscore.js, también utiliza una solución similar, pero es compatible con la carga del módulo AMD:
La copia del código es la siguiente:
;(función() {
/** Utilizado como referencia segura para 'Undefined` en entornos pre ES5*/
var indefinido;
/** Se utiliza para determinar si los valores son del objeto de tipo de idioma*/
var ObjectTypes = {
'boolean': falso,
'Función': Verdadero,
'objeto': verdadero,
'Número': Falso,
'cadena': falso,
'Undefinado': Falso
};
/** utilizado como referencia al objeto global*/
var root = (ObjectTypes [typeOf Window] && Window) || este;
/** Detectar variable gratuita `exports`*/
var freeExports = ObjectTypes [typeof exports] && exports &&! exports.nodetype && exports;
/** Detectar la variable gratuita `Module`*/
var freeModule = ObjectTypes [typeof module] && módulo &&! Module.nodeType && Module;
/** Detectar la popular extensión de CommonJS `módulo.exports`*/
var moduleExports = freemodule && freemodule.exports === freeExports && freeExports;
/*--------------------------------------------------------------------------*/
// Exponer lo-dash
var _ = runincontext ();
// Algunos optimizadores de construcción de AMD, como R.JS, verifican los patrones de condición como los siguientes:
if (typeof define == 'function' && typeof define.amd == 'objeto' && define.amd) {
// Expone lo-dash al objeto global incluso cuando un cargador AMD está presente en
// Case lo-dash fue inyectado por un script de terceros y no pretendía estar
// Cargado como un módulo. La tarea global se puede revertir en el lo-dash
// módulo por su método `noconflict ()`.
root._ = _;
// Definir como un módulo anónimo, por lo que, a través del mapeo de ruta, puede ser
// referenciado como el módulo "subrayado"
Define (function () {
devolver _;
});
}
// Verifique las `exportaciones` después de` Define` en caso de que un optimizador de compilación agrega un objeto 'Exports`
else if (freeExports && freemodule) {
// en node.js o ringojs
if (moduleExports) {
(freemodule.exports = _) ._ = _;
}
// en narval o rinoceronte -requerir
demás {
FreeExports._ = _;
}
}
demás {
// en un navegador o rinoceronte
root._ = _;
}
} .call (this));
Echemos un vistazo al código principal del momento. JS Cierre de encapsulación:
La copia del código es la siguiente:
(función (indefinida) {
momento var;
// Verifique NodeJS
var HasModule = (typeof module! == 'Undefined' && Module.Exports);
/********************************************************
Exposición de momento
********************************************
function MakeGlobal (deprecate) {
var advertir = false, local_moment = momento;
/ *Global Ender: falso */
if (typeOf Ender! == 'Undefined') {
devolver;
}
// Aquí, `this" significa `ventana 'en el navegador, o` global` en el servidor
// Agregar 'momento' como objeto global a través de un identificador de cadena,
// para el modo "avanzado" del compilador de cierre
if (deprecate) {
this.moment = function () {
if (! advertir && console && console.warn) {
advertido = verdadero;
console.warn (
"Acceder al momento a través del alcance global es" +
"Del desprecio y se eliminará en un próximo" +
"liberar.");
}
return local_moment.apply (nulo, argumentos);
};
} demás {
este ['momento'] = momento;
}
}
// se define el módulo CommonJS
if (hasModule) {
módulo.exports = momento;
makeGlobal (verdadero);
} else if (typeof define === "función" && define.amd) {
Definir ("momento", función (requerir, exportar, módulo) {
if (module.config (). Noglobal! == true) {
// Si el usuario proporciona noglobal, es consciente de Global
makeGlobal (módulo.config (). Noglobal === Undefined);
}
momento de regreso;
});
} demás {
makeGlobal ();
}
}). Llame (esto);
Como se puede ver en los ejemplos anteriores, al encapsular módulos que son comunes a node.js y front-end, se puede usar la siguiente lógica:
La copia del código es la siguiente:
if (typeof exports! == "indefinido") {
exportaciones. ** = **;
} demás {
esto. ** = **;
}
Es decir, si el objeto de exportación existe, la variable local se carga en el objeto de exportación, y si no existe, se carga en el objeto global. Si se agrega la compatibilidad de la especificación ADM, agregue una sentencia más al juzgar:
Copie el código del código de la siguiente manera: if (typeof define === "function" && define.amd) {}