O carregamento e a execução do módulo são embrulhados no Node.js, para que as variáveis no arquivo do módulo estejam em um fechamento e não poluem variáveis globais e entrem em conflito com outras pessoas.
Os módulos front-end geralmente são os que desenvolvedores colocam código do módulo em um fechamento para evitar conflitos com outras pessoas.
Como encapsular os módulos comuns ao Node.js e ao front-end, podemos nos referir à implementação do subscore.js. É um módulo de função funcional comum para node.js e front-end. Verifique o código:
A cópia do código é a seguinte:
// Crie uma referência segura ao objeto sublinhado para uso abaixo.
var _ = function (obj) {
if (obj instanceof _) retorna obj;
if (! (esta instância de _)) retorna novo _ (obj);
this._wrapd = obj;
};
// exportar o objeto sublinhado para ** node.js **, com
// Compatibilidade para trás para o antigo `requer ()` API. Se estamos dentro
// O navegador, adicione `_` como um objeto global por meio de um identificador de string,
// para o modo "avançado" do compilador de fechamento.
if (typeof exports! == 'indefinido') {
if (typeof módulo! == 'indefinido' && module.exports) {
exports = module.exports = _;
}
exports._ = _;
} outro {
root._ = _;
}
Decida atribuir variável local para exportações julgando se existem exportações, que é compatível com a API antiga requer (). Se no navegador, um identificador de string "_" é usado como um objeto global; O fechamento completo é o seguinte:
A cópia do código é a seguinte:
(function () {
// Configuração da linha de base
// ------------------
// Estabeleça o objeto raiz, `Window` no navegador, ou` exportações` no servidor.
var root = this;
// Crie uma referência segura ao objeto sublinhado para uso abaixo.
var _ = function (obj) {
if (obj instanceof _) retorna obj;
if (! (esta instância de _)) retorna novo _ (obj);
this._wrapd = obj;
};
// exportar o objeto sublinhado para ** node.js **, com
// Compatibilidade para trás para o antigo `requer ()` API. Se estamos dentro
// O navegador, adicione `_` como um objeto global por meio de um identificador de string,
// para o modo "avançado" do compilador de fechamento.
if (typeof exports! == 'indefinido') {
if (typeof módulo! == 'indefinido' && module.exports) {
exports = module.exports = _;
}
exports._ = _;
} outro {
root._ = _;
}
}). Ligue para (isso);
Um fechamento é construído através da definição da função e a chamada (isso) é chamar a função sob esse objeto para evitar variáveis internas que contaminam no escopo global. No navegador, isso aponta para um objeto global (objeto de janela), atribuindo a variável "_" ao objeto global "root._" para chamadas externas.
Lo-Dash, semelhante ao subsCore.js, também usa uma solução semelhante, mas é compatível com a carga do módulo AMD:
A cópia do código é a seguinte:
; (function () {
/** Usado como uma referência segura para `indefinido` em ambientes pré -es5*/
var indefinido;
/** usado para determinar se os valores são do objeto de tipo de idioma*/
var objectTypes = {
'booleano': falso,
'função': verdadeiro,
'objeto': verdadeiro,
'Número': falso,
'String': false,
'indefinido': false
};
/** usado como referência ao objeto global*/
var root = (objectTypes [Window TypeOf] && Window) || esse;
/** Detecte a variável livre `exportações`*/
var freeExports = objectTypes [typeof exports] && exports &&! exports.nodetype && exports;
/** Detecte a variável livre `Module`*/
var freemodule = objectTypes [módulo typeof] && módulo &&! module.nodetype && Module;
/** Detecte a extensão comum da extensão Commonjs `Module.Exports`*/
var moduleexports = freemodule && freeModule.exports === freeExports && freeexports;
/*------------------------------------------------------------------------*//
// Exponha lo-dash
var _ = runiContext ();
// Alguns otimizadores de construção da AMD, como R.Js, verifiquem padrões de condição como o seguinte:
if (typeof define == 'function' && typeof define.amd == 'object' && define.amd) {
// exponha lo-dash ao objeto global, mesmo quando um carregador AMD está presente em
// case lo-dash foi injetado por um script de terceiros e não pretendia ser
// carregado como um módulo. A tarefa global pode ser revertida no lo-dash
// módulo pelo seu método `noconflict ()`.
root._ = _;
// define como um módulo anônimo, para que, através do mapeamento de caminho, pode ser
// referenciado como o módulo "sublinhado"
define (function () {
retornar _;
});
}
// Verifique se há `exportações` após` define`, caso um otimizador de compilação adicione um objeto `exports`
else if (freeexports && freemodule) {
// em node.js ou ringojs
if (moduleexports) {
(freemodule.exports = _) ._ = _;
}
// em Narwhal ou Rhino -Require
outro {
freeExports._ = _;
}
}
outro {
// em um navegador ou rinoceronte
root._ = _;
}
} .call (this));
Vamos dar uma olhada no principal código de momento.
A cópia do código é a seguinte:
(função (indefinida) {
Var Moment;
// Verifique se há nodejs
var hasmodule = (tipoof módulo! == 'indefinido' && module.exports);
/********************************************************
Expondo momento
*********************************************
função makeglobal (deprecia) {
var avisado = false, local_moment = Moment;
/ *Global Ender: false */
if (typeof ender! == 'indefinido') {
retornar;
}
// aqui, `` isto significa 'janela' no navegador, ou 'global' no servidor
// Adicione `Moment` como um objeto global por meio de um identificador de string,
// para o modo "avançado" do compilador de fechamento
if (depreciar) {
this.moment = function () {
if (! Warned && Console && Console.warn) {
avisado = true;
console.warn (
"Acessar o momento através do escopo global é" +
"Depreciado e será removido em um próximo" +
"liberar.");
}
retornar local_moment.apply (nulo, argumentos);
};
} outro {
este ['momento'] = momento;
}
}
// O módulo Commonjs é definido
if (hasmodule) {
Module.Exports = Moment;
makeglobal (verdadeiro);
} else if (typeof define === "function" && define.amd) {
Definir ("Moment", função (requer, exportações, módulo) {
if (module.config (). Noglobal! == true) {
// Se o usuário forneceu Noglobal, ele está ciente de global
makeglobal (module.config (). Noglobal === indefinido);
}
momento de retorno;
});
} outro {
makeglobal ();
}
}). Ligue para (isso);
Como pode ser visto nos exemplos acima, ao encapsular módulos comuns ao node.js e front-end, a lógica a seguir pode ser usada:
A cópia do código é a seguinte:
if (typeof exports! == "indefinido") {
exportações. ** = **;
} outro {
isso. ** = **;
}
Ou seja, se o objeto de exportações existir, a variável local será carregada no objeto Exportação e, se não existir, será carregado no objeto global. Se a compatibilidade da especificação do ADM for adicionada, adicione mais uma frase ao juiz:
Copie o código do código da seguinte forma: if (typeof define === "function" && define.amd) {}