Mari kita lihat tujuan penutupan. Bahkan, dengan menggunakan penutupan, kita dapat melakukan banyak hal. Misalnya, simulasikan gaya kode yang berorientasi objek; kode ekspres lebih elegan dan ringkas; dan meningkatkan efisiensi eksekusi kode dalam beberapa aspek.
1 Fungsi pengendalian diri anonim
Kita tahu bahwa jika semua variabel tidak ditambahkan dengan kata kunci VAR, default akan ditambahkan ke properti objek global. Ada banyak kelemahan untuk menambahkan variabel sementara seperti itu ke objek global.
Misalnya: Fungsi lain dapat menyalahgunakan variabel -variabel ini; menyebabkan objek global terlalu besar dan mempengaruhi kecepatan akses (karena nilai variabel perlu dilalui dari rantai prototipe).
Selain menggunakan kata kunci VAR setiap kali kami menggunakan variabel, kami sering menghadapi situasi di mana beberapa fungsi hanya perlu dieksekusi sekali dan variabel internal mereka tidak perlu dipertahankan.
Misalnya, dalam inisialisasi UI, kita dapat menggunakan penutupan:
Salinan kode adalah sebagai berikut:
var datamodel = {
meja : [],
pohon : {}
};
(function (dm) {
untuk (var i = 0; i <dm.table.rows; i ++) {
var row = dm.table.rows [i];
untuk (var j = 0; j <row.cells; i ++) {
drawcell (i, j);
}
}
// Bangun DM.Tree
}) (datamodel);
Kami membuat fungsi anonim dan menjalankannya segera, karena eksternal tidak dapat merujuk variabel di dalamnya,
Oleh karena itu, itu akan dirilis segera setelah eksekusi. Kuncinya adalah bahwa mekanisme ini tidak akan mencemari objek global.
2 cache
Mari kita ambil contoh lain. Bayangkan bahwa kita memiliki objek fungsi yang sangat memakan waktu yang membutuhkan waktu lama untuk memproses setiap panggilan.
Maka kita perlu menyimpan nilai yang dihitung. Saat menyebut fungsi ini, pertama -tama kita mencari di cache. Jika tidak dapat ditemukan, kami akan melakukan perhitungan.
Kemudian perbarui cache dan kembalikan nilainya. Jika ditemukan, cukup kembalikan nilai yang ditemukan secara langsung. Penutupan melakukan hal ini, karena tidak merilis referensi eksternal,
Dengan demikian nilai di dalam fungsi dapat dipertahankan.
Salinan kode adalah sebagai berikut:
var cacheedsearchbox = (function () {
var cache = {},
hitung = [];
kembali {
IntoksearchBox: function (dsid) {
if (dsid dalam cache) {// jika hasilnya ada di cache
Return Cache [DSID]; // Kembalikan langsung ke objek dalam cache
}
var fsb = uikat.webctrl.searchbox baru (dsid); // baru
cache [dsid] = fsb; // perbarui cache
if (count.length> 100) {// ukuran cache dijamin <= 100
hapus cache [count.shift ()];
}
mengembalikan FSB;
},
clearsearchbox: function (dsid) {
if (dsid dalam cache) {
cache [dsid] .clearselection ();
}
}
};
}) ();
CachedSearchBox.AttachSearchBox ("Input1");
Dengan cara ini, ketika kita memanggil cacheedsearchbox.attachserachbox ("input1") untuk kedua kalinya,
Kami dapat mengakses objek dari cache tanpa membuat objek SearchBox baru.
3 Menerapkan kemasan
Pertama -tama mari kita lihat contoh tentang enkapsulasi. Variabel di dalamnya tidak dapat diakses di luar orang tersebut, tetapi diakses dengan memberikan penutupan:
Salinan kode adalah sebagai berikut:
var person = function () {
// Ruang lingkup variabel berada di dalam fungsi dan tidak dapat diakses di luar fungsi
var name = "default";
kembali {
getName: function () {
nama pengembalian;
},
setName: function (newname) {
name = newname;
}
}
} ();
cetak (person.name); // akses langsung, hasilnya tidak ditentukan
print (person.getName ());
orang.setname ("abruzzi");
print (person.getName ());
Hasilnya adalah sebagai berikut:
belum diartikan
bawaan
Abruzzi
4 Tujuan penting lain dari penutupan adalah untuk mengimplementasikan objek yang berorientasi objek. Bahasa objek tradisional menyediakan mekanisme templat kelas.
Dengan cara ini, objek yang berbeda (contoh kelas) memiliki anggota dan negara bagian independen dan tidak saling mengganggu. Meskipun tidak ada mekanisme seperti kelas dalam JavaScript, dengan menggunakan penutupan,
Kita dapat mensimulasikan mekanisme seperti itu. Mari kita bicara tentang contoh di atas:
Salinan kode adalah sebagai berikut:
function person () {
var name = "default";
kembali {
getName: function () {
nama pengembalian;
},
setName: function (newname) {
name = newname;
}
}
};
var John = orang ();
print (John.getName ());
John.setname ("John");
print (John.getName ());
var jack = orang ();
print (jack.getname ());
jack.setname ("jack");
print (jack.getname ());
Hasil operasi adalah sebagai berikut:
bawaan
John
bawaan
mendongkrak
Dari kode ini, kita dapat melihat bahwa John dan Jack dapat disebut contoh kelas orang, karena akses ke anggota nama independen dan tidak saling mempengaruhi.
Di atas adalah fungsi penutupan JS, yang sangat sederhana dan mudah dimengerti. Saya berharap ini akan membantu teman -teman saya.