DIV CSS 佈局教程網

深入JavaScript函式:物件、閉包、原型與建構子
編輯:關於JavaScript     

JavaScript 的函式不只是「一段可重複呼叫的程式碼」,它同時也是一種特殊的物件。理解這一點,之後的原型、建構子、閉包等概念才會連得起來。以下由淺入深整理。

基本寫法

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

宣告函式時,內容會被編譯但不會立即執行,直到我們呼叫它。而且關鍵的一點是:建立函式的同時,一個同名的物件也被建立了。

匿名函式與函式表達式

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(1, 2);

函式作為物件

函式是第一類(first-class)資料型別,代表它可以被賦值、傳參、附加屬性。

物件的建立

function ball() { // 這個宣告實際上建立了一個名為 ball 的物件
  i = 1;
}
alert(typeof ball); // "function"

甚至可以把內容印出來,會看到函式本身的程式碼:

alert(ball);
// function ball()
// {
//   i = 1;
// }

屬性的附加

function Ball() { }
ball.callsign = "The ball";
alert(ball.callsign); // "The ball"

指標與函式參照

function myFunction(message) {
  alert(message);
}
var ptr = myFunction; // ptr 指向 myFunction
ptr("hello");         // 等同 myFunction("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

巢狀函式

function get(a, b, c) {
  function cal(n) {
    return n / 2;
  }
  var result = "";
  result += cal(a) + " ";
  result += cal(b) + " ";
  result += cal(c);
  return result;
}
var resultString = get(10, 20, 30);
alert(resultString); // "5 10 15"

巢狀函式只能在內部呼叫。也就是說 getHalfOf.calculate(10) 這種寫法行不通,因為 calculate 只在外部函式執行期間存在。

名稱衝突時呼叫哪一個?

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

編譯器會優先搜尋局部作用域,因此這裡用的是內層的 calculate。若把內層版本刪掉,就會改用全域版本。這正是作用域鏈的運作方式。

函式作為資料型別的藍圖

函式另一個特殊能力是可以當成自訂資料型別的藍圖,這是模擬物件導向的基礎。

function Ball() { }
var ball0 = new Ball();
alert(ball0); // "object"

new Ball() 做了兩件事:建立一個新物件,然後執行 Ball() 並把該物件作為 this 傳入。

function Ball(message) {
  alert(message);
}
var ball0 = new Ball("creating new Ball"); // 建立物件並輸出訊息
ball0.name = "ball-0";
alert(ball0.name); // ball-0

上面第 4 行其實可以展開成:

var ball0 = new Object();
ball0.construct = Ball;
ball0.construct("creating new ball");
ball0.name = "ball-0";
alert(ball0.name);

用 this 自動附加屬性

若每個實例都要手動加屬性,很容易漏掉:

function Ball() { }
var ball0 = new Ball();
ball0.name = "ball-0";
var ball1 = new Ball();
ball1.name = "ball-1";
var ball2 = new Ball();
alert(ball0.name); // ball-0
alert(ball1.name); // ball-1
alert(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);
var balloon = new Ball("red", "Balloon", "Pete", 10);
alert(ball0.name);    // Soccer Ball
alert(balloon.name);  // Balloon
alert(ball2.weight);  // 55

屬性值也可以是物件:

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);
var teamLeader = new Employee("Rose", 50, boss);
alert(manager.supervisor.name + " is the supervisor of " + manager.name);

把函式當成屬性:效能上的差別

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

差別可以透過實驗驗證:

var boss1 = new Employee("John", 200000);
var boss2 = new Employee("Joan", 200000);

// getSalary 各自獨立
boss1.getSalary.owner = "boss1";
boss2.getSalary.owner = "boss2";
alert(boss1.getSalary.owner); // boss1
alert(boss2.getSalary.owner); // boss2

// addSalary 共用同一個函式物件
boss1.addSalary.owner = "boss1";
boss2.addSalary.owner = "boss2";
alert(boss1.addSalary.owner); // boss2
alert(boss2.addSalary.owner); // boss2

把函式寫在建構子內部的代價有兩個:一是每個實例都要保存一份程式碼拷貝,二是建立物件的時間變長。因此更好的寫法是把共用函式提到外部:

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

原型 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");

alert(fish1.name + "," + fish1.color + "," + fish1.livesIn + "," + fish1.price);
// mackarel, gray, water, 20

我們從未替每條魚個別宣告 livesIn 與 price,卻都能讀到。原因是物件被建立時,建構函式會把自己的 prototype 指派給新物件的內部屬性 [[Prototype]](舊寫法為 __proto__),而屬性查找會沿著這條原型鏈往上找。

用同樣的方式掛上共用方法,就不必在每次建立物件時重新產生一份函式:

function Employee(name, salary) {
  this.name = name;
  this.salary = salary;
}
Employee.prototype.getSalary = function () {
  return this.salary;
};
Employee.prototype.addSalary = function (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

三個實例各自有一個內部屬性指向 Employee 的 prototype,呼叫 getSalary 時,引擎在原型上找到並執行該程式碼。

補充兩點現代寫法:ES6 的 class 語法本質上就是原型繼承的語法糖,class 內部定義的方法自動掛在 prototype 上;而若要處理繼承關係,Object.create 與 ES6 的 extends 都比手動操作 __proto__ 來得可靠。

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