Méthode d'encapsulation des modules communs dans Node.js

Méthode d'encapsulation des modules communs dans Node.js_node.js

WBOY

Libérer： 2016-05-16 16:45:53

original

1673 Les gens l'ont consulté

Le chargement et l'exécution du module sont emballés dans Node.js afin que les variables du fichier du module soient fermées et ne polluent pas les variables globales ni n'entrent en conflit avec d'autres.

Pour les modules front-end, nos développeurs placent généralement le code du module dans une fermeture pour éviter les conflits avec les autres.

Comment encapsuler les modules communs à Node.js et au front-end, on peut se référer à l'implémentation d'Underscore.js, qui est un module de fonction fonctionnel commun à Node.js et au front-end, voir le code :

Copier le code Le code est le suivant :

 
// Créer une référence sécurisée au trait de soulignement objet à utiliser ci-dessous.
 var _ = function(obj) {
 if (obj instanceof _) return obj;
 if (!(this instanceof _)) return new _(obj);
 this._wrapped = obj;
 };

 // Exporte l'objet Underscore pour **Node.js**, avec
 // rétrocompatibilité pour l'ancienne API `require()` . Si nous sommes dans
 // le navigateur, ajoutez `_` comme objet global via un identifiant de chaîne,
 // pour le mode "avancé" de Closure Compiler.
 if (typeof exports !== 'indéfini' ) {
 if (type de module !== 'undéfini' && module.exports) {
 exports = module.exports = _;
 }
 exports._ = _;
 } else {
 root._ = _;
 }

Détermine s'il faut attribuer la variable locale _ aux exportations en jugeant si les exportations existent. Elle est rétrocompatible avec l'ancienne API require(). . Si dans le navigateur, en tant qu'objet global via un identifiant de chaîne "_" ; la fermeture complète est la suivante :

Copier le code Le code est le suivant :

(function() {

 // 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écurisée au Objet de soulignement à utiliser ci-dessous.
 var _ = function(obj) {
 if (obj instanceof _) return obj;
 if (!(this instanceof _)) return new _(obj);
 this._wrapped = obj; 
 };

 // Exporte l'objet Underscore pour **Node.js**, avec
 // rétrocompatibilité pour l'ancien `require()` API. Si nous sommes dans 
 // le navigateur, ajoutez `_` comme objet global via un identifiant de chaîne,
 // pour le mode "avancé" de Closure Compiler.
 if (typeof exports != = 'indéfini') {
 if (typeof module !== 'undefined' && module.exports) {
 exports = module.exports = _;
 }
 exports._ = _;
 } else {
 root._ = _;
 }
}).call(this);

Une fermeture est construite via la définition de la fonction. call(this) est la fonction appelée sous cet objet pour éviter que les variables internes ne contaminent la portée globale. Dans le navigateur, cela pointe vers l'objet global (objet fenêtre) et la variable "_" est affectée à l'objet global "root._" pour les appels externes.
Lo-Dash, qui est similaire à Underscore.js, utilise également une solution similaire, mais est compatible avec le chargement du module AMD :

Copier le code Le code est le suivant :

;(function() {

/**在 ES5 之前的環境中用作“undefined”的安全參考*/
var undefined;
    或
        '布林值': false,
        '函數': true,
           '字串': false,
'未定義': false
      };
/**用於確定值是否屬於語言類型 Object*/
var root = (objectTypes[typeof window] && window) || this root = (objectTypes[typeof window] && window) || this; var freeExports = objectTypes[typeof 出口] && 出口&& !exports.nodeType && 出口;

/**檢測自由變數“exports”*/

/**檢測自由變數“module”*/

/**檢測流行的 CommonJS 擴充 `module.exports`*/ /
/***/
var moduleExports = freeModule && freeModule.exports === free moduleExports = freeModule && freeModule.exports === free mod *-- ----------------------------------------------- --- ----------------------*/

// 公開Lo-Dash
var _ = runInContext();

// 一些AMD 建構最佳化器，如r.js，檢查如下所示的條件模式：
if (typeof Define == 'function' && typeof Define.amd == 'object' && Define .amd) {
    // 即使AMD 載入器存在於
    中，也將Lo-Dash 暴露給全域物件// 如果Lo-Dash 是由第三方腳本注入的，且不打算被
// 載入為一個模組。
    root._ = _;

    // 定義為匿名模組，因此，透過路徑映射，可
    // 定義為「底線」模組引用
🎜>      return _;
    });
}
// 檢查對於「define」之後的「exports」，以防止建構最佳化器加上「exports」物件
( ) {
    // 在Node.js 或RingoJS
    if (moduleExports) {
      (free 犀牛中-require
    else {
      freeExports._ = _;
    }
} }
}.call(this));

再來看看Moment .js的封裝閉包主要程式碼：

複製程式碼

程式碼如下：

 
(fonction (non définie) {
    var moment；
    // vérifier nodeJS
    var hasModule = (typeof module !== 'undefined' && module.exports)；
 /**********************************
       Moment d'exposition
    ******** ***************************/

    function makeGlobal(deprecate) {
        var warn = false, local_moment = moment;
        /*global ender:false */
       if (type de fin !== 'undefined') {
            return;
        }
        // ici, `this` 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 mode "avancé" de Closure Compiler
        if (obsolète) {
            this.moment = function () {
                 if (!warned && console && console.warn) {
                   warn = true;
                    console.warn(
                                      "                      "obsolète et sera supprimé dans un prochain " 
                            " release.");
                }
                return local_moment.apply(null, arguments);
            };
        } else {
             this['moment'] moment = ;
        }
    }

    // Le module CommonJS est défini
    if (hasModule) {
        module.exports = moment;
        makeGlobal(true);
    } else if (typeof definition = == "fonction" && définir.amd) {
        définir("moment", fonction (exiger, exports, 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 ;
        });
    } else {
        makeGlobal();
    }
}).call(this);

从上面的几个例子可以看出，在封装Node.js和前端通用的模块时，可以使用以下逻辑：

复制代码代码如下:

si ( typeof exports !== "undefined") {
    exports.** = **;
} else {
    this.** = **;
}

即， Les exportations, les exportations, les exportations, les exportations, les exportations, les exportations范的兼容性，那么多加一句判断：

复制代码代码如下 :

if (type de définition === "fonction" && définir.amd){}