DIV CSS 佈局教程網

深入 JavaScript:函式參數的六個細節與閉包的運作原理
編輯:關於JavaScript     

函式是 JavaScript 的一等物件。想真正學好這語言,就必須把函式吃透。這篇文章整理兩塊最容易含糊帶過的內容:參數的各種行為,以及閉包的形成機制與實用場景。

一、函式參數

1.1 參數是什麼

定義函式時,我們常需要傳入額外的資料,不同的外部輸入得到不同結果,這些外部資料就是參數。

function keith(a){ return a + a; }
console.log(keith(3)); // 6

1.2 參數可以省略

JavaScript 規範允許呼叫時省略實際參數,這點與多數語言不同。

function keith(a, b, c) { return a; }
console.log(keith(1, 2, 3)); // 1
console.log(keith(1));       // 1
console.log(keith());        // undefined

不管傳入幾個參數都不會報錯,被省略的參數值就是 undefined。要注意函式的 length 屬性回傳的是形式參數個數,與實際傳入的數量無關。

(實際參數:呼叫時傳入的。形式參數:定義時宣告的。)

不過,你無法只省略前面的參數而保留後面的。若一定要跳過前面的位置,只能顯式傳入 undefined:

function keith(a, b) { return a; }
console.log(keith(, 1));       // SyntaxError
console.log(keith(undefined, 2)); // undefined

1.3 參數預設值

JavaScript 中參數的預設值是 undefined。若需要不同的預設值,傳統做法是在函式主體內檢查:

function keith(a, b) {
    b = (typeof b !== 'undefined') ? b : 1;
    return a * b;
}
console.log(keith(15));    // 15
console.log(keith(15, 2)); // 30

從 ECMAScript 6 開始支援預設參數語法,函式體內的檢查就可以省掉了:

function keith(a, b = 1) { return a * b; }
console.log(keith(15));    // 15
console.log(keith(15, 2)); // 30

1.4 參數的兩種傳遞方式

傳值傳遞:當參數是原始型別(字串、數值、布林值)時採用。函式體內修改參數,不影響外部。

var a = 1;
function keith(num) { num = 5; }
keith(a);
console.log(a); // 1

因為函式內部拿到的是原始值的複本,怎麼改都不影響外部。

傳址傳遞:當參數是複合型別(陣列、物件、其他函式)時採用。傳入的是位址,因此函式內部修改會影響外部。

var arr = [2, 5];
function keith(Arr) { Arr[0] = 3; }
keith(arr);
console.log(arr[0]); // 3

但有一個重要例外:如果函式內部替換掉整個參數物件,而非修改它的屬性,就不會影響外部值。

var arr = [2, 3, 5];
function keith(Arr) { Arr = [1, 2, 3]; }
keith(arr);
console.log(arr); // [2, 3, 5]

原因是形式參數 Arr 與實際參數 arr 之間只是一層賦值關係,重新賦值 Arr 等同於讓它指向新的物件,原本 arr 的參照並未改變。

1.5 同名參數

若有同名參數,取最後出現的那個值;若最後一個未提供值,則結果為 undefined。

function keith(a, a) { return a; }
console.log(keith(1, 3)); // 3
console.log(keith(1));    // undefined

想存取第一個同名參數,得靠 arguments 物件:

function keith(a, a) { return arguments[0]; }
console.log(keith(2)); // 2

1.6 arguments 物件

JavaScript 中每個函式內部都能存取一個特殊變數 arguments,它維護著所有傳入該函式的參數清單。arguments[0] 是第一個參數,arguments[1] 是第二個,依此類推。這個物件只在函式體內部可用。

function keith(a, b, c) {
    console.log(arguments[0]);     // 1
    console.log(arguments[2]);     // 3
    console.log(arguments.length); // 4
}
keith(1, 2, 3, 4);

arguments 不是陣列

雖然它有 length 屬性,語法上看起來像陣列,但它並不繼承自 Array.prototype,本質上是一個「類陣列物件」。因此你無法對它使用 push、pop、slice 等標準陣列方法,只能用 length。

若需要真正轉成陣列,常見寫法是:

var arr = Array.prototype.slice.call(arguments);

二、閉包

2.1 閉包的定義與成因

理解閉包之前,得先分清全域作用域與區域作用域:函式內部可以存取全域變數,但函式外部無法存取函式內部定義的區域變數。

var a = 1;
function keith() { var b = 2; return a; }
console.log(keith()); // 1
console.log(b);       // ReferenceError: b is not defined

想取得函式內部的區域變數,唯一的辦法是在函式內部再定義一個函式:

function keith(){
    var a = 1;
    function rascal(){ return a; }
    return rascal;
}
var result = keith();
console.log(result()); // 1

也可以直接回傳匿名函式,效果相同:

function keith(){
    var a = 1;
    return function(){ return a; };
}
var result = keith();
console.log(result()); // 1

這裡起作用的是 JavaScript 特有的「鏈式作用域」結構:子物件會一層層向上搜尋所有父物件的變數。因此父物件的所有變數對子物件都是可見的,反之則不然。keith 回傳的 rascal 能讀取 keith 的內部變數,我們就在外部取得了 keith 的內部變數。

閉包指的就是 rascal 這樣的函式——能讀取其他函式內部變數的函式。由於 JavaScript 中只有函式內部的子函式才能讀取內部變數,閉包也可以簡單理解為「定義在函式內部的函式」。

閉包最大的特點是它能「記住」誕生的環境。rascal 記住了它的誕生源 keith,所以能從 keith 取得內部變數。反過來說,閉包讓它的誕生環境得以持續存在:

function keith(num) {
    return function() { return num++; };
}
var result = keith(2);
console.log(result()); // 2
console.log(result()); // 3
console.log(result()); // 4

參數 num 相當於 keith 內部的區域變數。透過閉包,num 的狀態被保留下來,每次呼叫都建立在前一次的結果上。這也說明閉包讓函式的內部環境一直存在於記憶體中。

閉包的三個特點:

  1. 在一個函式內部定義另一個函式,並回傳該內部函式或立即執行它。
  2. 內部函式可以讀取外部函式定義的區域變數。
  3. 讓區域變數始終保留在記憶體中,也就是讓誕生環境持續存在。

閉包的另一個實用場景是封裝私有屬性與私有方法:

function Keith(name) {
    var age;
    function setAge(n) { age = n; }
    function getAge() { return age; }
    return { name: name, setAge: setAge, getAge: getAge };
}
var person = Keith('keith');
person.setAge(21);
console.log(person.name);    // 'keith'
console.log(person.getAge()); // 21

age 被藏在閉包裡,外部只能透過 setAge 與 getAge 操作,無法直接存取。這是 JavaScript 在 class 語法普及之前實作私有的標準手法。

2.2 立即呼叫的函式表達式(IIFE)

IIFE 通常只用於匿名函式,目的有兩個:一是免去了命名,避免污染全域變數;二是 IIFE 內部形成獨立作用域,可以封裝外部讀不到的私有變數。

循環中的閉包陷阱

最常見的閉包錯誤出現在迴圈中。假設我們希望在每次迴圈裡印出序號:

for(var i = 0; i < 10; i++){
    setTimeout(function(){ console.log(i); }, 1000)
}

結果並不會如預期印出 0 到 9,而是連續印出十次 10。原因是匿名函式執行時仍持有對全域變數 i 的參照,等 1 秒後它真的被執行時,for 迴圈早已結束,i 的值已被改成 10。

用 IIFE 在每次迴圈中建立 i 的複本即可解決:

for(var i = 0; i < 10; i++) {
    (function(e) {
        setTimeout(function() { console.log(e); }, 1000);
    })(i);
}

外層匿名函式立即執行,把當下的 i 作為參數傳入,函式內的 e 因此擁有 i 的一份複本。稍後傳給 setTimeout 的匿名函式持有的是對 e 的參照,而 e 不會被迴圈改變。

這也是 let 相較 var 的關鍵優勢所在:用 let 宣告迴圈變數時,每次迭代都會產生一個新的綁定,上述問題自然消失,不需要再包一層 IIFE。

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