從閉包函式的變數自增的角度-解析js垃圾回收機制

const times = (()=>{
  var times = 0;
  return () => times++;
})()
console.log(
  times(),
  times(),
  times(),
  times()
) // 0，1，2，3，複製程式碼

const times = ((times = 0)=> () => times++)()
console.log(
  times(),
  times(),
  times(),
  times()
) // 0，1，2，3複製程式碼

let time = 0
const times = ()=>{
	let time = 10
	return function(){
		return time++
	} 
}// 根據JavaScript作用域鏈地規則，閉包內部沒有，就從外面拿變數

const a = times();  // times函式只被執行了1次，產生了一個變數 time
console.log(
	a(),          // 而times返回的匿名函式卻被執行了5次
	a(),          // 而times返回的匿名函式卻被執行了5次
	a(),          // 而times返回的匿名函式卻被執行了5次   其中的差別相差非常遠
	a(),          // 而times返回的匿名函式卻被執行了5次
	a()           // 而times返回的匿名函式卻被執行了5次
) // 0，1，2，3複製程式碼

const times = ((times = 0)=> () => times++)()();  匿名函式只被執行了一次，同時返回函式再次執行一次
console.log(
  times,   // 得到匿名函式返回值， 函式只有配合()才會被執行一次麼，此處
  times,   // 此處沒有函式被執行
  times,   // 因此列印值為四個零
  times
)； // 0，0，0，0複製程式碼

const times = ((times = 0)=> () => times++); time相當於宣告式函式
console.log(
  times()(),    // 此處外部函式執行一次，產生times變數，返回的函式再執行一次times引用次數為0
  times()(),    // 此處外部函式執行一次，產生times變數，返回的函式再執行一次
  times()(),    // 此處外部函式執行一次，產生times變數，返回的函式再執行一次
  times()()
)； // 0，0，0，0複製程式碼

const arr = [1,2,3,3,5,6,4,78].entries()
console.log(
  arr2.next().value,
  arr2.next().value,
  arr2.next().value,
  arr2.next().value,
  arr2.next().value
); // [0, 1], [1, 2], [2, 3], [3, 3], [4, 5]  迭代器返回值， 【index，value】複製程式碼

{ 
  rss: 23560192,         // 所有記憶體佔用，包括指令區和堆疊。
  heapTotal: 10829824,   // "堆"佔用的記憶體，包括用到的和沒用到的。
  heapUsed: 4977904,     // 用到的堆的部分。同時也是判斷記憶體是否洩露的標準。
  external: 8608         // V8 引擎內部的 C++ 物件佔用的記憶體。
}複製程式碼

const timeFunc = ((time = 0)=> () => time++)
var b = timeFunc();   // time 變數引用次數+1，不能被回收
console.log(b());
console.log(b());
console.log(b());複製程式碼

// 真的非常神奇，需要滿足2個條件
// 1.變數命名於返回函式外部，函式函式內部。
// 2.返回函式引用外部變數，導致外部變數無法觸發垃圾回收機制。因為引用次數>1
let timeFunc = (time = 0)=>{
  return (() => time++)()
}
var b = timeFunc();  // b變數接受的是timeFunc返回的函式，由於返回函式內部有引用外部變數，故
console.log(b)
console.log(b)複製程式碼

var n = 123;   // 給數值變數分配記憶體
var s = "azerty"; // 給字串變數分配記憶體

var obj = {
	a: 1,
	b: null
};  // 給物件以及其包含的值分配記憶體

var arr = [1,null,"abra"]; // 給函式（可呼叫的物件）分配記憶體

function f(a){
	return a+2
} // 給函式（可呼叫物件）分配記憶體

// 為函式表示式也分配一段記憶體
document.body.addEventListener(`scroll`, function (){
	console.log(`123`)
},false)複製程式碼

var data = new Date();
var a = document.createElement(`div`);複製程式碼

var s1 = `azerty`;   // 由於字串屬於引用，所以JavaScript不會為他分配新的記憶體
var s2 = `s.substr(0,3)`; // s2是一個新的字串

var a = ["ouais ouais", "nan nan"];
var a2 = ["generation", "nan nan"];
var a3 = a.concat(a2); 
// 新陣列有四個元素，是 a 連線 a2 的結果複製程式碼

var o = {
	a: {
		b: 2
	}
};
// 兩個物件被建立，一個作為另一個的屬性被引用，另一個被分配給變數o
// 很顯然，沒有一個可以被作為辣雞收集

var o2 = o; // o2變數是第二個對“這個物件”

o = 1;   // 現在這個物件的原始引用o被o2替換了

var oa = o2.a; // 引用“這個物件”的a屬性
                 // 現在，“這個物件”有兩個引用了，一個是o2，一個是oa

o2 = `yo`;  // 最初的物件現在已經是零引用了
		// 它可以被垃圾回收了
		// 然而他的屬性a還在被呼叫，所以不能回收

oa = null;	// a屬性的那個物件現在也是零引用了
		// 它可以被垃圾回收了複製程式碼