Pemuatan dan eksekusi modul dibungkus dalam node.js sehingga variabel dalam file modul sedang dalam penutupan dan tidak akan mencemari variabel global dan konflik dengan orang lain.
Modul front-end biasanya yang kami pengembang menempatkan kode modul dalam penutupan untuk menghindari konflik dengan orang lain.
Cara merangkum modul yang umum untuk node.js dan front-end, kita dapat merujuk pada implementasi underscore.js. Ini adalah modul fungsi fungsional yang umum untuk node.js dan front-end. Periksa kodenya:
Salinan kode adalah sebagai berikut:
// Buat referensi yang aman ke objek underscore untuk digunakan di bawah ini.
var _ = fungsi (obj) {
if (obj instance dari _) mengembalikan obj;
if (! (Contoh ini _)) mengembalikan _ baru (obj);
this._wrapped = obj;
};
// Ekspor objek bawah untuk ** node.js **, dengan
// Kompatibilitas ke belakang untuk `membutuhkan ()` API lama. Jika kita masuk
// browser, tambahkan `_` sebagai objek global melalui pengidentifikasi string,
// untuk Mode Penutupan Kompiler "Advanced".
if (typeof ekspor! == 'tidak terdefinisi') {
if (typeof module! == 'tidak terdefinisi' && module.exports) {
Ekspor = Module.Exports = _;
}
Exports._ = _;
} kalau tidak {
root._ = _;
}
Putuskan untuk menetapkan variabel lokal untuk mengekspor dengan menilai apakah ada ekspor, yang kompatibel dengan API yang lama (). Jika di browser, pengidentifikasi string "_" digunakan sebagai objek global; Penutupan lengkap adalah sebagai berikut:
Salinan kode adalah sebagai berikut:
(fungsi() {
// Pengaturan Baseline
// ----------------
// buat objek root, `window` di browser, atau` ekspor` di server.
var root = ini;
// Buat referensi yang aman ke objek underscore untuk digunakan di bawah ini.
var _ = fungsi (obj) {
if (obj instance dari _) mengembalikan obj;
if (! (Contoh ini _)) mengembalikan _ baru (obj);
this._wrapped = obj;
};
// Ekspor objek bawah untuk ** node.js **, dengan
// Kompatibilitas ke belakang untuk `membutuhkan ()` API lama. Jika kita masuk
// browser, tambahkan `_` sebagai objek global melalui pengidentifikasi string,
// untuk Mode Penutupan Kompiler "Advanced".
if (typeof ekspor! == 'tidak terdefinisi') {
if (typeof module! == 'tidak terdefinisi' && module.exports) {
Ekspor = Module.Exports = _;
}
Exports._ = _;
} kalau tidak {
root._ = _;
}
}). Panggil (ini);
Penutupan dibangun melalui definisi fungsi, dan panggilan (ini) adalah untuk memanggil fungsi di bawah objek ini untuk menghindari variabel internal yang terkontaminasi ke dalam ruang lingkup global. Di browser, ini menunjuk ke objek global (objek jendela), menetapkan variabel "_" ke objek global "root._" untuk panggilan eksternal.
Lo-dash, mirip dengan underscore.js, juga menggunakan solusi serupa, tetapi kompatibel dengan pemuatan modul AMD:
Salinan kode adalah sebagai berikut:
;(fungsi() {
/** Digunakan sebagai referensi yang aman untuk `tidak ditentukan` di lingkungan pra ES5*/
var tidak terdefinisi;
/** Digunakan untuk menentukan apakah nilai dari objek tipe bahasa*/
var objectTypes = {
'boolean': false,
'Fungsi': Benar,
'Objek': Benar,
'Nomor': Salah,
'string': false,
'tidak terdefinisi': false
};
/** digunakan sebagai referensi ke objek global*/
var root = (objectTypes [typeof window] && window) || ini;
/** Deteksi variabel gratis `ekspor`*/
var freeExports = ObjectTypes [typeof Exports] && Exports &&! Exports.nodetype && Exports;
/** Deteksi variabel gratis `module`*/
var freemodule = objectTypes [typeof module] && modul &&! Module.nodetype && module;
/** Mendeteksi ekstensi CommonJs yang populer `module.Exports`*/
var moduleExports = freemodule && freemodule.exports === FreeExports && freeExports;
/*--------------------------------------------------------------------------
// Ekspos Lo-dash
var _ = runincontext ();
// Beberapa pengoptimal membangun AMD, seperti R.JS, periksa pola kondisi seperti berikut:
if (typeOf define == 'function' && typeOf define.amd == 'objek' && define.amd) {
// Ekspos Lo-dash ke objek global bahkan ketika AMD loader hadir
// case lo-dash disuntikkan oleh skrip pihak ketiga dan tidak dimaksudkan untuk menjadi
// dimuat sebagai modul. Penugasan global dapat dikembalikan di lo-dash
// Modul dengan metode `noconflict ()` -nya.
root._ = _;
// Tentukan sebagai modul anonim sehingga, melalui pemetaan jalur, itu bisa
// dirujuk sebagai modul "menggarisbawahi"
define (function () {
kembali _;
});
}
// Periksa `Ekspor` setelah` define` Jika pengoptimal build menambahkan objek `ekspor`
lain if (freeExports && freemodule) {
// di node.js atau ringojs
if (moduleExports) {
(freemodule.Exports = _) ._ = _;
}
// di narwhal atau rhino -lestquire
kalau tidak {
FreeExports._ = _;
}
}
kalau tidak {
// di browser atau badak
root._ = _;
}
} .call (ini));
Mari kita lihat kode utama momen.js penutupan enkapsulasi:
Salinan kode adalah sebagai berikut:
(fungsi (tidak terdefinisi) {
momen var;
// periksa nodej
var hasmodule = (typeof module! == 'tidak terdefinisi' && module.exports);
/**************************************************
Momen Mengekspos
*****************************************/
fungsi makeGlobal (decrecate) {
var diperingatkan = false, local_moment = momen;
/ *Global Ender: Salah */
if (typeof ender! == 'tidak terdefinisi') {
kembali;
}
// Di sini, `this` berarti` window` di browser, atau `global` di server
// Tambahkan `momen` sebagai objek global melalui pengidentifikasi string,
// Mode "Advanced" Compiler untuk Penutupan
if (usang) {
this.moment = function () {
if (! warning && console && console.warn) {
diperingatkan = benar;
Console.warn (
"Mengakses momen melalui ruang lingkup global adalah" +
"Teram, dan akan dihapus dalam" + yang akan datang
"melepaskan.");
}
return local_moment.apply (null, argumen);
};
} kalau tidak {
ini ['momen'] = momen;
}
}
// Modul CommonJS didefinisikan
if (hasmodule) {
module.Exports = momen;
makeGlobal (true);
} else if (typeof define === "function" && define.amd) {
Tentukan ("momen", fungsi (membutuhkan, ekspor, modul) {
if (module.config (). noglobal! == true) {
// Jika pengguna memberikan noglobal, dia sadar akan global
makeGlobal (module.config (). noglobal === tidak ditentukan);
}
momen kembali;
});
} kalau tidak {
makeGlobal ();
}
}). Panggil (ini);
Seperti dapat dilihat dari contoh-contoh di atas, ketika merangkum modul yang umum untuk node.js dan front-end, logika berikut dapat digunakan:
Salinan kode adalah sebagai berikut:
if (typeof ekspor! == "tidak terdefinisi") {
ekspor. ** = **;
} kalau tidak {
ini. ** = **;
}
Artinya, jika objek ekspor ada, variabel lokal dimuat pada objek ekspor, dan jika tidak ada, itu dimuat pada objek global. Jika kompatibilitas spesifikasi ADM ditambahkan, maka tambahkan satu kalimat lagi untuk menilai:
Salin kode kode sebagai berikut: if (typeOf define === "function" && define.amd) {}