Memahami mekanisme kitar semula js dalam kemahiran version_javascript yang mudah difahami

Dalam artikel sebelum ini, saya telah menerangkan mekanisme kitar semula dalam js, tetapi bagi saya pada masa itu, saya agak keliru tentang konsep mekanisme kitar semula Sekarang saya mempunyai pemahaman yang lebih mendalam tentang mekanisme kitar semula, jadi dengan ini Post ini artikel untuk meringkaskan dan mendalami ingatan anda.
Mengapa terdapat mekanisme kitar semula? kenapa?

Sebagai contoh, saya mempunyai kad memori Memori ini adalah 8G. Saya menyimpan fail, video dan muzik ke kad memori ini untuk menyimpan fail lain ke kad memori ini, saya perlu memadam beberapa fail Tetapi fail yang dipadam ini dipadam secara manual oleh kami, bukan?

Masalah ini juga berlaku dalam bahasa pengaturcaraan ini, ya, ingatan! Sebarang pembolehubah yang kami isytiharkan menggunakan memori, dan semakin banyak pembolehubah yang kami ada, semakin perlahan ia akan berjalan. Bukan sahaja pembolehubah sudah tentu, apa-apa dalam kod. Untuk menyelesaikan masalah ini, pereka bentuk bahasa ini mereka bentuk satu set peraturan kitar semula kod.

Peraturan kitar semula kod adalah seperti berikut:

1. Pembolehubah global tidak akan dikitar semula.

2. Pembolehubah setempat akan dikitar semula, iaitu sebaik sahaja fungsi selesai dijalankan, segala-galanya di dalam fungsi akan dimusnahkan.

3. Selagi ia dirujuk oleh skop lain, ia tidak akan dikitar semula

Saya menggunakan beberapa contoh untuk membuktikannya.

function a(){
 var user = "追梦子";
 return user;
}
var b = a();
console.log(b); //追梦子 

Secara logiknya, saya tidak boleh mengakses pembolehubah dalam fungsi a, tetapi saya menerima nilai pulangan fungsi a melalui pembolehubah global b, jadi kod akhir menjadi seperti berikut.

function a(){
 var user = "追梦子";
 return user;
}
var b = "追梦子";
console.log(b);

Nampaknya tiada kitar semula kod dalam perkara ini, jadi mari lihat sekeping kod seterusnya.

function a(){
 var num = 0;
 return function(){
  num ++;
  console.log(num);
 };
}
var b = a();
b(); //1
b(); //2
b(); //3

Lihat, jika anda mengikuti amalan biasa, output hendaklah 3 kali dan 1 kali, kerana sebaik sahaja badan fungsi dijalankan, kod dalam badan fungsi akan dikosongkan Memandangkan ia akan dikosongkan, jalankan bahagian ini seterusnya masa Semasa menulis kod, num masih harus 1, tetapi keadaan di sini adalah sedikit berbeza yang saya katakan di atas bahawa selagi pembolehubah tempatan dalam fungsi dirujuk oleh skop lain, kod ini tidak akan dimusnahkan.

Kod di atas kelihatan seperti ini

function a(){
 var num = 0;
 return function(){
  num ++;
  console.log(num);
 };
}
var b = function(){
  num ++;
  console.log(num);
 };
b();
b();
b();

Kemudian skop fungsi tanpa nama yang dikembalikan oleh fungsi a dialihkan daripada fungsi a ke tetingkap Memandangkan fungsi tanpa nama ini dirujuk oleh pembolehubah global b, ia tidak akan dimusnahkan.

function a(){
 var num = 0;
 return function(){
  num ++;
  console.log(num);
 };
}
var b = {
 fn:a()
}
b.fn(); //1
b.fn(); //2
b.fn(); //3

Begitu juga, kerana fungsi tanpa nama dirujuk oleh atribut fn objek b, mengubah skopnya, selagi fungsi atau pembolehubah tempatan diubah dalam skop, fungsi atau pembolehubah tempatan tidak akan musnah.
Di atas adalah keseluruhan kandungan artikel ini, saya harap anda boleh mendapatkan bantuan dalam mekanisme kitar semula js.