DIV CSS 佈局教程網

JavaScript 作用域、作用域鏈與閉包完整解析
編輯:JavaScript基礎知識     

一、JavaScript 中的作用域

變數依宣告位置可分為兩類:函數外宣告的是全域變數,函數內宣告的是局部變數。

1. 函數級作用域

JavaScript 與 C#、Java 這類語言不同。在那些語言中採用的是塊級作用域,區塊內宣告的變數不會影響外部;而 JavaScript 採用的是函數級作用域,也就是說,建立作用域的單位是函數,而不是大括號。

先看 C# 的例子:

static void Main(string[] args) {
  for (var x = 1; x < 10; x++) {
    Console.WriteLine(x.ToString());
  }
  Console.WriteLine(x.ToString()); // 編譯錯誤
}

這段程式碼會得到編譯錯誤:The name 'x' does not exist in the current context。

同樣的邏輯寫成 JavaScript:

<script>
function main() {
  for (var x = 1; x < 10; x++) {
    console.log(x.toString());
  }
  console.log(x.toString());
}
main();
</script>

輸出會是 1 到 9,最後再印出一個 10,完全不報錯。

這正好說明了塊級作用域與函數級作用域的差別:塊級作用域離開區塊後外部就不能用,x 離開 for 迴圈後在 C# 中已不存在;但 JavaScript 裡它還活得好好的,甚至還能被存取。

2. 變數提升

function func() {
  console.log(x); // undefined
  var x = 1;
  console.log(x); // 1
}
func();

第一次為什麼是 undefined?這牽涉到 JavaScript 的「變數提升」。其實叫「宣告提升」會更精確一些,因為被提前的只有宣告,賦值並不會一起被搬上去——這也就是第一次印不出 1 的原因。上面的程式碼實際上等同於:

function func() {
  var x;
  console.log(x); // undefined
  var x = 1;
  console.log(x); // 1
}
func();

3. 宣告時要不要寫 var

這是一個很值得注意的細節。

var x = 1;

function addVar() {
  var x = 2;
  console.log(x);
}

addVar();
console.log(x); // 1,全域的 x 沒有被影響

但若把函數內部的 var 拿掉:

var x = 1;

function delVar() {
  x = 2;
  console.log(x);
}

delVar();
console.log(x); // 2,全域的 x 被改掉了

結論很清楚:函數內部宣告變數時若省略 var,該變數就會成為全域變數。這也是為什麼在嚴格模式('use strict')下這類寫法會直接拋出錯誤——它確實是個容易釀成事故的陷阱。

二、作用域鏈

先看這段程式:

var name = "Global";

function t() {
  var name = "t_Local";

  function s1() {
    var name = "s1_Local";
    console.log(name);
  }

  function s2() {
    console.log(name);
  }

  s1();
  s2();
}

t();

輸出結果是 s1_Local 與 t_Local。兩個問題隨之而來:為什麼第二次不是 s1_Local?又為什麼不是 Global?

答案就在作用域鏈。程式建立完成時會形成上圖那樣的鏈狀結構,因此呼叫 s1() 時,console.log(name) 先在自己的作用域中找,找到 s1_Local 就輸出了。呼叫 s2() 時過程相同,只是自身作用域裡沒有 name,於是往上一層找,在 t() 中找到,於是印出 t_Local。

如果把 t 裡的 name 刪掉,結果就會變成:

s1_Local
Global

這也說明了為什麼在 JavaScript 中應該盡量減少使用 with——它會在作用域鏈上插入臨時物件,讓變數的查找路徑變得難以預判,同時也阻礙引擎做優化。

三、閉包

理解作用域與作用域鏈之後,閉包就好懂多了。

1. 閉包的第一個作用:跨越作用域取用變數

function s1() {
  var x = 123;
  return s2();
}

function s2() {
  return x;
}

alert(s1()); // Uncaught ReferenceError: x is not defined

s2 裡沒有 x 的定義,沿著作用域鏈往上到全域也找不到,於是報錯。也就是說 s1 與 s2 無法共享 x。那該怎麼拿到 s1 裡的 x?

function s1() {
  var x = 123;
  return function () {
    return x;
  };
}

var test = s1();
console.log(test()); // 123

關鍵在於函數本質上也是資料,它和 x 處於同一個作用域,因此能存取 x。這樣就相當於對外開放了一個可以讀取內部變數的介面。

換個寫法也可以:

var func;

function f() {
  var x = '123';
  func = function () {
    return x;
  };
}

f();
alert(func());

宣告一個全域變數,在函數內部讓它指向一個函數,之後就能透過這個全域變數存取 x。

所以閉包是什麼?它就像函數內部與外部之間的一座橋,讓外部得以存取函數內部的變數。這是閉包的第一個作用。

2. 閉包的第二個作用:讓變數常駐記憶體

function f1() {
  var n = 1;

  add = function () {
    n += 1;
  };

  function f2() {
    console.log(n);
    return '輸出完成';
  }

  return f2;
}

var res = f1();
console.log(res()); // 1
add();
console.log(res()); // 2

為什麼第二次印出的是 2,n 沒有被清掉?我的理解是:res 是全域變數,會一直駐留在記憶體中,而它指向的 f2 又依賴 f1 的作用域,因此 f1 的環境也不會被垃圾回收機制清掉。每次呼叫 add 就相當於改寫了 f1 中的 n,值自然跟著改變。這就是閉包的第二個作用:讓變數的值持續保存在記憶體中。

反過來說,這也是閉包容易造成記憶體洩漏的原因——用不到的閉包要記得清掉引用。

3. 閉包的實際應用

① 做存取控制,相當於 C# 中的屬性:

// 準備兩個變數,分別存放取值與存值方法
var get, set;

(function () {
  var x = 0; // 設定預設值

  set = function (n) {
    x = n;
  };

  get = function () {
    return x;
  };
})();

console.log(get()); // 0
set(5);
console.log(get()); // 5

外部只能透過 get 與 set 操作 x,無法直接改寫,達到封裝的效果。

② 用作迭代器:

function foo(myArray) {
  var i = 0;

  // 閉包迭代器
  next = function () {
    // 每次回傳目前元素,索引 +1
    return myArray[i++];
  };
}

foo(['a', 'b', 'c', 'd']);

console.log(next()); // a
console.log(next()); // b
console.log(next()); // c
console.log(next()); // d

③ 閉包在迴圈中的經典陷阱:

function f() {
  var a = [];
  var i;

  for (i = 0; i < 3; i++) {
    a[i] = function () {
      return i;
    };
  }

  return a;
}

var test = f();
console.log(test[0]()); // 3
console.log(test[1]()); // 3
console.log(test[2]()); // 3

為什麼不是 0、1、2?因為閉包記住的是變數的引用,而不是每一次迴圈當時的值。三個函數指向的都是同一個 i,等到我們呼叫它們時,迴圈早已結束,i 停在 3。

想拿到 0、1、2,得在迴圈中製造獨立的作用域:

function f() {
  var a = [];
  var i;

  for (i = 0; i < 3; i++) {
    a[i] = (function (x) {
      return function () {
        return x;
      };
    })(i);
  }

  return a;
}

var test = f();
console.log(test[0]()); // 0
console.log(test[1]()); // 1
console.log(test[2]()); // 2

這裡用立即執行函數把當下的 i 當成參數傳進去,等於為每次迴圈各存了一份獨立的 x,於是就得到預期的結果。若環境支援 ES6,直接用 let 宣告迴圈變數也能達到同樣效果,因為 let 天生具備塊級作用域。

XML學習教程| jQuery入門知識| AJAX入門| Dreamweaver教程| Fireworks入門知識| SEO技巧| SEO優化集錦|
Copyright © DIV+CSS佈局教程網 All Rights Reserved