DIV CSS 佈局教程網

JavaScript 函數完全指南:從基礎定義到閉包應用
編輯:JavaScript基礎知識     

什麼是函數(Function)

先用最直白的話說:函數就是一段有名字、可以重複使用的程式碼區塊。最簡單的例子如下:

function sum(a, b) {
    return a + b;
}

幾個容易踩坑的細節值得留意:

1. JavaScript 是區分大小寫的語言,關鍵字 function 不能寫成 Function 或 FUNCTION。

2. sum 是函數名稱,它並非必要(後面會談到匿名函數)。

3. return 用來回傳結果;若不寫,函數會預設回傳 undefined。想回傳多個值時,可以回傳陣列或物件。

函數的呼叫

最基礎的呼叫方式就是帶上函數名稱與括號:

var result = sum(1, 2);

函數的參數

參數行為是本篇的重點,以下用幾個實例說明。

實例一:傳入參數少於定義的參數

var result = sum(1);

此時 result 為 NaN,因為參數 b 的值是 undefined。它不會報錯,反而容易在不知不覺中埋下 bug。

實例二:傳入參數多於定義的參數

sum(1, 2, 3, 4, 5);

結果為 3,多餘的參數會被忽略。

實例三:沒有宣告參數的函數

function args() {
    return arguments;
}

每個函數內部都有一個預設的類陣列物件 arguments,它保存了所有實際傳入的參數。呼叫 args(1,2,3,4,5,6) 時,arguments 的值就是 [1,2,3,4,5,6]。利用這一點,我們可以把上面的 sum 改寫得更靈活:

function sum() {
    var res = 0;
    for (i = 0; i < arguments.length; i++) {
        res += arguments[i];
    }
    return res;
}
sum(1, 2, 3, 4); // 10

函數也是一種資料(Functions are data)

這是一個很重要的觀念:函數本身就是資料。看看下面兩種寫法:

function f() { return 1; }
var f = function() { return 1; };

這兩種定義完全等價。執行 typeof f 會得到 "function",可見在 JavaScript 中函數是一種資料型別。它有兩個重要特性:包含程式碼,並且能被執行。

再看一個例子:

var sum = function(a, b) { return a + b; };
var add = sum;
sum = undefined;
typeof add; // "function"
add(1, 2);  // 3

把函數 sum 當成一個值賦給 add 之後,即使 sum 被設為 undefined,add 依然可以正常呼叫。這說明函數只是一次普通的賦值。

匿名函數(Anonymous Functions)

在 JavaScript 中,像 "abcd"、1、[1,2,3] 這樣不寫賦值目標的資料不會報錯,它們被稱為匿名資料。函數作為資料同樣可以是匿名的:

function(a) { return a; }

匿名函數有兩個主要用途:一是作為參數傳入另一個函數;二是立即執行它。

回呼函數(Callback Functions)

既然函數可以像其他資料一樣被賦值、複製,自然也就能作為參數傳入另一個函數。

實例一

function invoke_and_add(a, b) {
    return a() + b();
}
function one() { return 1; }
function two() { return 2; }
invoke_and_add(one, two); // 3

實例二

invoke_and_add(function() { return 1; }, function() { return 2; });

直接把匿名函數當參數傳入,不需要額外命名。

回呼函數的定義是:把函數 A 傳入函數 B,並由函數 B 來執行函數 A,我們就稱函數 A 為回呼函數。若沒有名稱,則稱為匿名回呼函數。

回呼函數的主要好處有三點:不必為傳遞的函數額外命名,可減少全域變數;能節省大量程式碼;並有助於提升程式效能。

自呼叫函數(Self-invoking Functions)

自呼叫函數是匿名函數的一種形式,定義之後立即執行:

(
function() {
    alert('haha');
}
)()

語法看起來有點特別,但概念很簡單。它不必額外定義全域變數,而且只會執行一次,非常適合拿來做初始化工作。許多知名的 JavaScript 函式庫(例如 jQuery)的原始碼中大量運用了這個技巧。

內部函數(Inner Functions)

既然函數是資料,而資料可以定義在函數裡,那麼把函數放進函數中也完全可行:

function a(param) {
    function b(theinput) {
        return theinput * 2;
    }
    return 'The result is ' + b(param);
}

也可以寫成:

var a = function(param) {
    var b = function(theinput) {
        return theinput * 2;
    };
    return 'The result is ' + b(param);
};

函數 b 定義在 a 內部,因此 a 的外部無法存取 b,這種函數也被稱為私有函數(private function)。執行 b(2) 會發現它並未定義,正好印證了它的私有性。

使用內部函數有兩個好處:減少全域變數,避免命名衝突帶來的 bug;具備私有性,可以設計出更完善的介面供外部呼叫。

回傳函數的函數(Functions that Return Functions)

function a() {
    alert('a');
    return function() {
        alert('b');
    };
}

呼叫 a() 會執行 alert('a'),並回傳另一個函數。使用方式如下:

var newFunc = a();
newFunc(); // 依序 alert a、alert b

也可以簡寫為 a()();。

函數的自我重寫

既然函數能回傳函數,也就意味著可以用新函數替換舊函數:

a = a();

第一次執行 a 時 alert a,之後執行 a 則 alert b。這個技巧對初始化非常有用,因為 a 重寫了自己,避免日後重複執行初始化邏輯。

更簡潔的做法是在函數內部直接重寫自己:

function a() {
    alert("a");
    a = function() {
        alert("b");
    };
}

只有第一次呼叫才會 alert a,之後都會 alert b。

綜合前面幾節,來看一個整合的例子:

var c = function() {
    function a() { alert('a'); }
    function b() { alert('b'); }
    a();
    return b;
}(); // alert('a');
c(); // alert('b');

這個例子要注意三點:a、b 是內部函數;return b 回傳的是函數的參考;自呼叫的結果重寫了函數 c。理解這個例子,就能同時掌握內部函數、自呼叫函數與回傳函數的函數。

閉包(Closures)

閉包是較難的部分,學習前先了解 JavaScript 的作用域(Scope)。

作用域鏈(Scope Chain)

var a = 1;
function f() {
    var b = 1;
    return a;
}
f(); // a = 1
b;   // b 未定義

a 是全域變數,b 定義在函數 f 內部。因此在 f 中 a、b 都可存取;在 f 之外則只能存取 a。

再看:

var a = 1;
function f() {
    var b = 1;
    function n() {
        var c = 3;
    }
}

函數 n 定義在 f 內部,它不僅能存取自己作用域的 c,還能存取父作用域的 b 與 a,這就是作用域鏈。

詞法作用域(Lexical Scope)

JavaScript 採用詞法作用域,也就是函數在「定義」時就確定了作用域,而非在「呼叫」時。

function f1() { var a = 1; f2(); }
function f2() { return a; }
f1(); // a 未定義

雖然 f1 呼叫了 f2,你可能期望 f2 能存取 f1 的區域變數 a,但事實並非如此。因為 f2 早已定義完成,其作用域中找不到 a。無論 f1 還是 f2,都只能存取自身的區域變數或全域變數。

用閉包打破作用域鏈(Breaking the Chain with Closure)

實例 1:

function f() {
    var b = "b";
    return function() {
        return b;
    };
}

變數 b 存在於 f 的作用域中,全域無法直接存取。但 f 回傳的新函數可以存取 b:

var n = f();
n(); // 存取 b

實例 2:函數 f 不回傳函數,而是建立一個全域變數 n:

var n;
function f() {
    var b = "b";
    n = function() {
        return b;
    };
}

如此便能直接以 n() 存取 f 內的變數 b。

由此可以說:當一個函數指向它的父作用域(尤其是父作用域中的區域變數)時,就形成了閉包。閉包其實提供了一個介面,讓外部得以存取內部變數。

當我們建立一個帶參數的函數 f,參數就成了 f 的區域變數,我們可以建立一個內部函數來回傳它:

function f(arg) {
    var n = function() {
        return arg;
    };
    arg++;
    return n;
}
var m = f(123);
m(); // 124

閉包在迴圈中的應用

迴圈中很容易出現表面正常、實際有誤的 bug:

function f() {
    var a = [];
    var i;
    for (i = 0; i < 3; i++) {
        a[i] = function() {
            alert(i);
            return i;
        };
    }
    return a;
}
var a = f();
a[0](); // 3
a[1](); // 3
a[2](); // 3

我們期望得到 0、1、2,結果卻都是 3。原因是這三個閉包都指向同一個變數 i,閉包記住的是 i 的「參考」而非當時的值。迴圈結束後 i 為 3,所以結果都是 3。

正確的寫法:

function f() {
    var a = [];
    var i;
    for (i = 0; i < 3; i++) {
        a[i] = (function(x) {
            return function() {
                alert(x);
                return x;
            };
        })(i);
    }
    return a;
}
var a = f();
a[0](); // 0
a[1](); // 1
a[2](); // 2

這裡再用一個閉包把 i 變成區域變數 x,每次的 x 都是不同的值。若不易理解自呼叫函數,也可以寫成:

function f() {
    function makeClosure(x) {
        return function() {
            return x;
        };
    }
    var a = [];
    var i;
    for (i = 0; i < 3; i++) {
        a[i] = makeClosure(i); // 用來記住 i 的值
    }
    return a;
}
XML學習教程| jQuery入門知識| AJAX入門| Dreamweaver教程| Fireworks入門知識| SEO技巧| SEO優化集錦|
Copyright © DIV+CSS佈局教程網 All Rights Reserved