函數是 JavaScript 的一等公民,而作用域規則決定了變數在哪裡可見、什麼時候被建立。搞懂這兩件事,很多「莫名其妙」的錯誤就會消失。本文從函數定義與呼叫講到閉包、變數提升與塊級作用域。
function abs(x) {
if (x >= 0) {
return x;
} else {
return -x;
}
}
這段定義包含四個部分:function 宣告這是一個函數;abs 是函數名稱;括號內是參數列表,多個參數以逗號分隔;大括號內是函數主體,可以包含任意多條陳述式,甚至完全空白。
執行到 return 時函數立即結束並回傳結果,因此函數內部可以靠條件判斷與迴圈實作出相當複雜的邏輯。若沒有任何 return,函數執行完畢後會回傳 undefined。
JavaScript 的函數本身就是一個物件,函數名稱只是指向它的變數。因此下面兩種寫法完全等價:
function abs(x) {
return x >= 0 ? x : -x;
}
var abs = function (x) {
return x >= 0 ? x : -x;
}; // 這裡的 function (x) {...} 是匿名函數,分號代表賦值陳述式結束
JavaScript 不檢查呼叫時的參數個數。傳多了會被忽略,傳少了則對應的參數是 undefined:
abs(10); // 10 abs(10, 'blablabla'); // 10(多出來的參數被忽略) abs(-9, 'haha', null); // 9 abs(); // NaN,因為 x 是 undefined
若不想讓 NaN 悄悄出現,可以在函數開頭做型別檢查:
function abs(x) {
if (typeof x !== 'number') {
throw 'Not a number';
}
return x >= 0 ? x : -x;
}
每個函數內部都有一個 arguments,它指向「呼叫者實際傳入的所有參數」,即使函式沒有宣告任何參數也拿得到:
function foo(x) {
alert(x); // 10
for (var i = 0; i < arguments.length; i++) {
alert(arguments[i]); // 10, 20, 30
}
}
foo(10, 20, 30);
function abs() {
if (arguments.length === 0) return 0;
var x = arguments[0];
return x >= 0 ? x : -x;
}
abs(); // 0
abs(10); // 10
abs(-9); // 9
最常見的用法是判斷參數個數,藉此把中間參數變成「可選」:
// foo(a, b, c),接受 2~3 個參數
function foo(a, b, c) {
if (arguments.length === 2) {
// 實際只傳了兩個,把 c 視為可選
c = b;
b = null;
}
// ...
}
在 ES6 之前,要取得「除了已宣告參數之外」的其餘參數,必須手動用 arguments 迴圈,而且索引要從 2 開始跳過前兩個,寫起來很別扭:
function foo(a, b) {
var i, rest = [];
if (arguments.length > 2) {
for (i = 2; i < arguments.length; i++) {
rest.push(arguments[i]);
}
}
console.log('a =', a, 'b =', b, 'rest =', rest);
}
ES6 的 rest 參數直接把這件事簡化成一行,前面加上 ...,而且必須放在參數列表最後:
function foo(a, b, ...rest) {
console.log('a =', a);
console.log('b =', b);
console.log(rest);
}
foo(1, 2, 3, 4, 5); // a = 1, b = 2, rest = [3, 4, 5]
foo(1); // a = 1, b = undefined, rest = []
注意:參數沒填滿時,rest 收到的是空陣列,而不是 undefined。
JavaScript 引擎有「在行尾自動補分號」的機制,這讓下面這段看似正常的程式碼出了問題:
function foo() {
return
{ name: 'foo' }; // 這行永遠不會執行
}
foo(); // undefined
引擎把 return 後面補上了分號,等於 return undefined;。正確的多行寫法是讓左大括號緊跟在 return 之後:
function foo() {
return {
name: 'foo'
};
}
用 var 宣告的變數,作用域是「整個函數」;在函數外自然無法存取:
'use strict';
function foo() {
var x = 1;
x = x + 1;
}
x = x + 2; // ReferenceError: x is not defined
不同函數各自宣告的同名變數互不干擾:
'use strict';
function foo() {
var x = 1;
x = x + 1;
}
function bar() {
var x = 'A';
x = x + 'B';
}
'use strict';
function foo() {
var x = 1;
function bar() {
var y = x + 1; // bar 可以讀取 foo 的 x
return y;
}
return bar();
}
foo(); // 2
反過來則不行:foo 無法存取 bar 內部的 y,會丟出 ReferenceError。若內外層變數同名,內層會「遮蔽」外層:
'use strict';
function foo() {
var x = 1;
function bar() {
var x = 'A';
alert('x in bar() = ' + x); // A
}
alert('x in foo() = ' + x); // 1
bar();
}
JavaScript 會先掃過整個函數主體,把 var 宣告「提升」到函數頂部,但賦值仍留在原地:
'use strict';
function foo() {
var x = 'Hello, ' + y;
alert(x);
var y = 'Bob';
}
foo(); // Hello, undefined
引擎實際看到的順序是:
function foo() {
var y; // 宣告被提升
var x = 'Hello, ' + y;
alert(x);
y = 'Bob'; // 賦值留在原處
}
因此實務上的好習慣是「在函數開頭一次宣告所有會用到的變數」:
function foo() {
var x = 1,
y = x + 1,
z, i; // z 與 i 為 undefined
for (i = 0; i < 100; i++) {
// ...
}
}
不在任何函數內宣告的變數具有全域作用域,實際上會被綁到 window 上:
'use strict'; var course = 'Learn JavaScript'; alert(course); // Learn JavaScript alert(window.course); // Learn JavaScript
這也意味著不同 JavaScript 檔若用了相同的全域變數或同名頂層函數,就會互相覆蓋,而且很難察覺。常見的解法是把自己的所有東西收進一個唯一的命名空間物件:
// 全域只保留 MYAPP 這一個變數
var MYAPP = {};
MYAPP.name = 'myapp';
MYAPP.version = '1.0';
MYAPP.foo = function () {
return 'foo';
};
var 沒有塊級作用域,在 for 迴圈裡宣告的變數出了迴圈依然存在,這正是古典迴圈 closure 問題的來源:
function foo() {
for (var i = 0; i < 100; i++) { }
i += 100; // 合法,i 仍然可見
}
ES6 的 let 提供真正的塊級作用域:
function foo() {
var sum = 0;
for (let i = 0; i < 100; i++) {
sum += i;
}
i += 1; // ReferenceError
}
const 宣告常數,同樣具有塊級作用域。要注意 const 限制的是「不能重新指派」,物件內容仍可變動:
const PI = 3.14; PI = 3; // TypeError(部分環境靜默失敗) const list = [1, 2]; list.push(3); // 合法,參考指向不變
· 函數是物件,宣告式會被提升,函數表達式不會
· arguments 是類陣列,rest 參數是真正的陣列,優先用後者
· return 後不要換行
· var 是函數作用域並有提升行為,let/const 是塊級作用域
· 能用 const 就用 const,其次 let,避免 var