Dalam JavaScript, apabila dua fungsi bersarang antara satu sama lain, fungsi dalaman ialah penutupan. Penutupan ialah fungsi yang mempunyai akses kepada pembolehubah dalam skop fungsi lain Cara yang paling biasa untuk membuat penutupan ialah mencipta fungsi lain dalam fungsi dan mengakses pembolehubah tempatan fungsi ini melalui fungsi lain.
Persekitaran pengendalian tutorial ini: sistem Windows 7, versi JavaScript 1.8.5, komputer Dell G3.
Penutupan ialah fungsi yang boleh membaca pembolehubah dalaman fungsi lain. Dalam JavaScript, hanya subfungsi dalam fungsi boleh membaca pembolehubah setempat, jadi penutupan boleh difahami sebagai "fungsi yang ditakrifkan dalam fungsi." Pada dasarnya, penutupan ialah jambatan antara bahagian dalam fungsi dan bahagian luar fungsi. (Aplikasi penutupan yang paling tipikal adalah untuk melaksanakan fungsi panggil balik).
Kelebihan:
1 , Lindungi keselamatan pembolehubah dalam fungsi
2. Kekalkan pembolehubah dalam ingatan (menggunakan terlalu banyak akan menjadi kelemahan dan menduduki memori
3. Kesinambungan logik, apabila ditutup Apabila digunakan sebagai parameter dalam panggilan fungsi lain, ia menghalang anda daripada menulis logik tambahan secara berasingan daripada logik semasa.
4. Pembolehubah setempat yang memudahkan konteks panggilan.
5. Mengukuhkan enkapsulasi boleh mencapai perlindungan pembolehubah.
Kelemahan:
1. Memori residen akan meningkatkan penggunaan memori dengan mudah menyebabkan kebocoran memori.
2. Terdapat juga masalah yang sangat serius, iaitu masalah sisa ingatan ini bukan sahaja kerana ia berada dalam ingatan, tetapi yang lebih penting, penggunaan penutupan yang tidak betul akan menyebabkan penjanaan ingatan tidak sah.
Ciri:
1. Fungsi bersarang fungsi
2. Fungsi dalaman boleh mengakses pembolehubah fungsi luaran
3. Parameter dan pembolehubah tidak akan dikitar semula.
Untuk memahami penutupan, tidak cukup dengan memahami konsep penutupan di atas sahaja. Pertama, anda mesti memahami skop pembolehubah khas JavaScript.
1. Hanya terdapat dua skop pembolehubah: pembolehubah global dan pembolehubah tempatan.
2. Keistimewaan bahasa JavaScript ialah pembolehubah global boleh dibaca terus di dalam fungsi, tetapi pembolehubah tempatan di dalam fungsi tidak boleh dibaca di luar fungsi.
3. Nota: Apabila mengisytiharkan pembolehubah di dalam fungsi, pastikan anda menggunakan arahan var. Jika anda tidak menggunakannya, anda sebenarnya mengisytiharkan pembolehubah global!
Proses penciptaan penutupan dalam Javascript adalah seperti yang ditunjukkan dalam program berikut.
function a () {
var i = 0;
function b () {
alert (i++);
}
return b;
}
var c = a();
c(); //函数调用Ciri Kod
Kod ini mempunyai dua ciri:
1. Fungsi b bersarang dalam fungsi Dalam a;
2. Fungsi a mengembalikan fungsi b.
Dengan cara ini, selepas melaksanakan var c = a(), pembolehubah c sebenarnya menunjuk ke fungsi b Selepas melaksanakan c() sekali lagi, tetingkap akan muncul untuk memaparkan nilai i (kali pertama ialah 1) . Kod ini sebenarnya mencipta penutupan kerana pembolehubah c fungsi luar a merujuk kepada fungsi b dalam fungsi a. Dalam erti kata lain, apabila fungsi b dalam fungsi a dirujuk oleh pembolehubah di luar fungsi a, penutupan dibuat.
Fungsi
Ringkasnya, fungsi penutupan adalah untuk membolehkan kutipan sampah Javascript selepas a dilaksanakan dan dipulangkan sumber yang diduduki oleh a, kerana pelaksanaan fungsi dalaman a b perlu bergantung pada pembolehubah dalam a.
Dalam contoh di atas, disebabkan kewujudan penutupan, i dalam a akan sentiasa wujud selepas fungsi a kembali Dengan cara ini, setiap kali c() dilaksanakan, i akan menjadi nilai i iaitu dimaklumkan selepas menambah 1. .
Kemudian mari bayangkan situasi lain Jika a mengembalikan sesuatu selain daripada fungsi b, keadaannya berbeza sama sekali. Kerana selepas a dilaksanakan, b tidak dikembalikan ke dunia luar a, tetapi hanya dirujuk oleh a Pada masa ini, a hanya akan dirujuk oleh b. Oleh itu, fungsi a dan b merujuk antara satu sama lain tetapi tidak terganggu oleh dunia luar (dirujuk oleh dunia luar , fungsi a dan b akan dikitar semula).
Senario Aplikasi
1 Lindungi pembolehubah dalam fungsi. Dalam fungsi a, i hanya boleh diakses oleh fungsi b dan tidak boleh diakses melalui cara lain, sekali gus melindungi keselamatan i.
2. Kekalkan pembolehubah dalam ingatan. Oleh kerana penutupan, i dalam fungsi a sentiasa wujud dalam ingatan, jadi setiap kali c() dilaksanakan, i akan dinaikkan sebanyak 1.
出于种种原因，我们有时候需要获取到函数内部的局部变量。但是，上面（三、变量作用域）已经说过了，正常情况下，这是办不到的！只有通过变通的方法才能实现。那就是在函数内部，再定义一个函数。
function demo1 () {
var n = 6699;
function demo2 () {
alert(n); // 6699
}
}在上面的代码中，函数 demo2 就被包括在函数demo1内部，这时demo1内部的所有局部变量，对demo2都是可见的。但是反过来就不行，demo2内部的局部变量，对demo1就是不可见的。
这就是Javascript语言特有的”链式作用域”结构（chain scope），子对象会一级一级地向上寻找所有父对象的变量。所以，父对象的所有变量，对子对象都是可见的，反之则不成立。
既然demo2可以读取demo1中的局部变量，那么只要把demo2作为返回值，我们不就可以在demo1外部读取它的内部变量了吗！
闭包可以用在许多地方。它的最大用处有两个，一个是前面提到的可以读取函数内部的变量，另一个就是让这些变量的值始终保持在内存中，不会在demo1调用后被自动清除。
那为什么会这样呢？原因就在于demo1是demo2的父函数，而demo2被赋给了一个全局变量，这导致demo2始终在内存中，而demo2的存在依赖于demo1，因此demo1也始终在内存中，不会在调用结束后，被垃圾回收机制（garbage collection）回收。
1、由于闭包会使得函数中的变量都被保存在内存中，内存消耗很大，所以不能滥用闭包，否则会造成网页的性能问题，在IE中可能导致内存泄露。解决方法是，在退出函数之前，将不使用的局部变量全部删除。
2、闭包会在父函数外部，改变父函数内部变量的值。所以，如果你把父函数当作对象（object）使用，把闭包当作它的公用方法（Public Method），把内部变量当作它的私有属性（private value），这时一定要小心，不要随便改变父函数内部变量的值。
1、闭包是指有权访问另一个函数作用域中的变量的函数，创建闭包的最常见的方式就是在一个函数内创建另一个函数，通过另一个函数访问这个函数的局部变量。闭包的缺点就是常驻内存，会增大内存使用量，使用不当很容易造成内存泄露。
2、不适合场景：返回闭包的函数是个非常大的函数。
闭包的典型框架应该就是jquery了。
闭包是javascript语言的一大特点，主要应用闭包场合主要是为了：设计私有的方法和变量。
这在做框架的时候体现更明显，有些方法和属性只是运算逻辑过程中的使用的，不想让外部修改这些属性，因此就可以设计一个闭包来只提供方法获取。
3、 不必纠结到底怎样才算闭包，其实你写的每一个函数都算作闭包，即使是全局函数，你访问函数外部的全局变量时，就是闭包
的体现。
更多编程相关知识，请访问：编程入门！！
Atas ialah kandungan terperinci Apakah penutupan dalam javascript. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!
![[Web front-end] Permulaan pantas Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
