DIV CSS 佈局教程網

JavaScript 函數完全入門:從定義到原型
編輯:JavaScript基礎知識     

函數是 JavaScript 世界裡最核心的 building block。只要理解了函數,你就掌握了這個語言大半的靈魂。本文整理自一篇廣為流傳的經典入門教程,從「如何定義函數」一路談到「函數作為物件」與「原型(prototype)」機制,適合想打好基礎的開發者細細研讀。

一、函數的三種定義方式

在 JavaScript 中定義函數並不止一種寫法。以下幾種都是合法的,但它們在底層的實作方式其實存在差異。

1. 函數宣告(最常見)

大多數人使用的標準寫法如下:

functionName([parameters]) { functionBody };

例如:

function add(a, b)
{
    return a + b;
}
alert(add(1, 2));   // 結果 3

當你用這種方式定義時,函數內容會先被編譯(但不會立即執行,除非你主動呼叫它)。此外還有一個容易被忽略的細節:建立函數的同時,一個同名的物件也被悄悄建立了。就上面的例子而言,此刻你手上其實有一個名為 add 的物件。

2. 指派給變數(匿名函數)

你也可以把一個匿名函數指派給某個變數來完成定義:

var add = function(a, b)
{
    return a + b;
}
alert(add(1, 2));   // 結果 3

這段程式碼和前一種寫法效果相同。語法看起來有點陌生,但它更能凸顯「函數本身就是一個物件」這個觀念——你不過是替這個物件取了一個名字,就像 var myVar = [1,2,3] 一樣。這種寫法同樣會被編譯。

指派時,函數並不一定是匿名的。你也可以替它命名,此後透過函數名或變數名都能呼叫它:

var add = function theAdd(a, b)
{
    return a + b;
}
alert(add(1, 2));    // 結果 3
alert(theAdd(1, 2)); // 結果同樣是 3

這種寫法在物件導向程式設計中特別有用,因為我們可以輕易地把函數變成某個物件的屬性(方法):

var myObject = new Object();
myObject.add = function(a, b) { return a + b; };
// myObject 現在擁有一個名為 add 的方法
myObject.add(1, 2);

3. 使用 new Function(最罕見)

透過 new 運算子也能定義函數,但這是最少見、也最不推薦的方式,除非有特別的理由。語法如下:

varName = new Function([param1Name, param2Name, ... paramNName], functionBody);

例如:

var add = new Function("a", "b", "return a + b;");
alert(add(3, 4));   // 結果 7

請注意 Function 的 F 是大寫,這告訴 JavaScript 我們要建立一個型別為 Function 的物件;同時參數名稱與函數體都是以「字串」形式傳入的。JavaScript 知道最後一個字串就是函數體,因此你可以自由增加參數。若程式碼太長,可用反斜線 \ 或字串串接 + 換行撰寫。

這種方式最大的缺點是:函數不會被編譯,因此執行效率可能較差。原因在下面的例子裡一目了然:

function createMyFunction(myOperator)
{
    return new Function("a", "b", "return a " + myOperator + " b;");
}
var add      = createMyFunction("+");   // 建立加法函數
var subtract = createMyFunction("-");   // 建立減法函數
var multiply = createMyFunction("*");   // 建立乘法函數

alert("加的結果=" + add(10, 2));       // 12
alert("減的結果=" + subtract(10, 2));  // 8
alert("乘的結果=" + multiply(10, 2));  // 20

由於編譯器無法事先得知最終的程式碼長相,new Function(...) 的內容便無法被編譯。這種技巧的價值在於「讓使用者自行建立函數」的情境,例如遊戲中允許玩家賦予角色自訂「行為」。除此之外,一般情況應盡量避免。

二、函數作為一種物件

函數是 JavaScript 裡一種特殊的物件,也是第一個「類別資料型別(class data type)」。這意味著我們能為它加上屬性。

前面提過,定義函數時 JavaScript 會在背後建立一個同名物件,其型別為 function。以下例子裡,我們其實已經建立了一個名為 Ball 的物件:

function Ball()   // 這行宣告建立了一個名為 Ball 的物件
{
    i = 1;
}
alert(typeof Ball);   // 結果 "function"

既然函數是物件,我們就能為它加上屬性:

function Ball() { }
Ball.callsign = "The Ball";   // 為 Ball 增加屬性
alert(Ball.callsign);         // 輸出 "The Ball"

函數指標

因為函數是物件,我們可以把它的「指標」指派給變數。下例中,變數 ptr 指向了物件 myFunction:

function myFunction(message)
{
    alert(message);
}
var ptr = myFunction;   // ptr 指向 myFunction
ptr("hello");           // 相當於 myFunction("hello"),輸出 "hello"

函數指標在物件導向中非常實用,例如讓多個物件共用同一個函數:

function sayName(name) { alert(name); }
var object1 = new Object();
var object2 = new Object();
var object3 = new Object();
object1.sayMyName = sayName;   // 將同一函數指派給三個物件
object2.sayMyName = sayName;
object3.sayMyName = sayName;

object1.sayMyName("object1");  // 輸出 "object1"
object2.sayMyName("object2");  // 輸出 "object2"
object3.sayMyName("object3");  // 輸出 "object3"

由於儲存的是指標而非函數本體,當函數物件自身改變時,所有指向它的指標都會跟著改變:

function myFunction() { alert(myFunction.message); }
myFunction.message = "old";
var ptr1 = myFunction;
var ptr2 = myFunction;

ptr1();   // 輸出 "old"
ptr2();   // 輸出 "old"

myFunction.message = "new";
ptr1();   // 輸出 "new"
ptr2();   // 輸出 "new"

我們也可以在函數建立後重新指派它,但必須針對函數物件本身,而非它的指標:

function myFunction() { alert("Old"); }
myFunction();   // 輸出 "Old"
myFunction = function() { alert("New"); };
myFunction();   // 輸出 "New"

舊函數被捨棄了。若想保留,可在變更前先存一個指標:

function myFunction() { alert("Old"); }
var savedFunction = myFunction;
myFunction = function() { alert("New"); };
myFunction();     // 輸出 "New"
savedFunction();  // 輸出 "Old"

但要小心:如果你改的是指標變數本身,只會建立另一個函數,並不會影響原本的函數。

巢狀函數

函數裡面還可以再包一個函數。下例中 getHalfOf 內部有一個 calculate:

function getHalfOf(num1, num2, num3)
{
    function calculate(number)
    {
        return number / 2;
    }
    var result = "";
    result += calculate(num1) + " ";
    result += calculate(num2) + " ";
    result += calculate(num3);
    return result;
}
var resultString = getHalfOf(10, 20, 30);
alert(resultString);   // 輸出 "5 10 15"

巢狀函數只能在內部呼叫,你不能從外部用 getHalfOf.calculate(10) 存取它,因為 calculate 只在外部函數執行期間存在。

那麼命名衝突怎麼辦?若內外都有名為 calculate 的函數,編譯器會先搜尋局部作用域,因此會採用內嵌的版本;若刪去內嵌函數,才會退回使用全域的 calculate。

三、函數作為資料型別與建構函數

函數還有一個與眾不同的能力:它能作為一個資料型別的「藍圖」。這在物件導向中被廣泛用來模擬使用者自訂的資料型別。

定義一個函數的同時,其實也定義了一個新的資料型別,可以用來建立物件:

function Ball() { }
var ball0 = new Ball();   // ball0 指向一個新物件
alert(ball0);             // 輸出 "Object"

new Ball() 做了什麼?new 關鍵字先建立一個型別為 Object 的新物件,接著執行 Ball(),再把這個參照交給 ball0。

然而,若每次建立物件後都要手動補上屬性,當有多個實例時就會很麻煩——很容易漏掉某個:

var ball0 = new Ball();
ball0.name = "ball-0";
var ball1 = new Ball();
ball1.name = "ball-1";
var ball2 = new Ball();
// 糟糕,我忘了幫 ball2 加上 name!

解法是使用 this 關鍵字。在函數中,this 指向呼叫該函數的物件。把它寫進建構函數裡,就能自動為每個實例設定屬性:

function Ball(message, specifiedName)
{
    alert(message);
    this.name = specifiedName;
}
var ball0 = new Ball("creating new Ball", "Soccer Ball");
alert(ball0.name);   // 輸出 "Soccer Ball"

是 new 關鍵字讓建構函數真正被執行,此時 this 指向 ball0,所以 this.name = specifiedName 就等於 ball0.name = "Soccer Ball"。這種寫法更具擴充性,也能讓人一眼看懂這個型別有哪些屬性:

function Ball(color, specifiedName, owner, weight)
{
    this.name   = specifiedName;
    this.color  = color;
    this.owner  = owner;
    this.weight = weight;
}
var ball0 = new Ball("black/white", "Soccer Ball", "John", 20);
var ball1 = new Ball("gray", "Bowling Ball", "John", 30);
var ball2 = new Ball("yellow", "Golf Ball", "John", 55);

屬性不限於字串或數字,也可以放物件。例如讓 supervisor 成為 Employee 的一個屬性:

function Employee(name, salary, mySupervisor)
{
    this.name = name;
    this.salary = salary;
    this.supervisor = mySupervisor;
}
var boss = new Employee("John", 200);
var manager = new Employee("Joan", 50, boss);

既然函數也是物件,我們甚至能讓函數充當屬性(也就是方法):

function Employee(name, salary)
{
    this.name = name;
    this.salary = salary;
    this.addSalary = addSalaryFunction;
    this.getSalary = function()
    {
        return this.salary;
    };
}
function addSalaryFunction(addition)
{
    this.salary = this.salary + addition;
}
var boss = new Employee("John", 200000);
boss.addSalary(10000);
alert(boss.getSalary());   // 210000

這裡有個關鍵差異:像 getSalary 這種寫在建構函數內的函數,每建立一個實例就會複製一份程式碼,既耗記憶體又拖慢建構速度;而 addSalary 只是指向同一個函數。若把方法都提到外部定義,就能讓所有實例共用同一份程式碼,效率更好——而更進一步的優化,正是下一節要談的 prototype。

四、函數與原型(prototype)

每個建構函數都自帶一個名為 prototype 的屬性,用來宣告某個類別共用的變數或函數。你不需要明確宣告它,因為它天生就存在:

function Test() { }
alert(Test.prototype);   // 輸出 "Object"

由於 prototype 是一個物件,你能為它加上屬性,而這些屬性會成為所有實例的共用屬性:

function Fish(name, color)
{
    this.name = name;
    this.color = color;
}
Fish.prototype.livesIn = "water";
Fish.prototype.price = 20;

var fish1 = new Fish("mackarel", "gray");
var fish2 = new Fish("goldfish", "orange");
var fish3 = new Fish("salmon", "white");

即使我們從未替每條魚個別宣告 livesIn 與 price,牠們都擁有這些屬性。原因是物件建立時,建構函數會把自己的 prototype 指派給新物件的內部屬性 __proto__,物件便是靠它來查找屬性。

用 prototype 來掛共用函數有個明顯好處:不必在每次建立物件時重新建立並初始化函數。把前面的 Employee 例子改寫如下:

function Employee(name, salary)
{
    this.name = name;
    this.salary = salary;
}
Employee.prototype.getSalary = function getSalaryFunction()
{
    return this.salary;
};
Employee.prototype.addSalary = function addSalaryFunction(addition)
{
    this.salary = this.salary + addition;
};

var boss1 = new Employee("Joan", 200000);
var boss2 = new Employee("Kim", 100000);
var boss3 = new Employee("Sam", 150000);

alert(boss1.getSalary());   // 200000
alert(boss2.getSalary());   // 100000
alert(boss3.getSalary());   // 150000

此時每個實例(boss1、boss2、boss3)都透過內部的 __proto__ 指向建構函數的 prototype;呼叫方法時,物件會在 __proto__ 中找到並執行對應程式碼。與前面「每個實例各複製一份」的寫法相比,這裡完全沒有程式碼的複製,這正是 prototype 機制強大又高效的地方。

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