JavaScript 是 prototype based programming 的語言,和我們熟悉的 class based programming 差別很大,幾個要點如下:
1. 函數是 first class object,也就是函數與對象地位相同
2. 沒有類,只有對象
3. 函數也是一種對象,即函數對象
4. 對象按引用傳遞
那這種語言如何實現繼承(OO 的核心要素之一)呢?這正是 prototype 的由來。
看下面的代碼:
function foo(a, b, c) { return a*b*c; } alert(foo.length); alert(typeof foo.constructor); alert(typeof foo.call); alert(typeof foo.apply); alert(typeof foo.prototype);
瀏覽器運行後你會發現:
1. length:函數的參數個數
2. prototype:一個 object
3. 其餘三個都是 function
任何函數聲明都會具備上述 5 個 property。下面重點看 prototype。
// prototype function Person(name, gender) { this.name = name; this.gender = gender; this.whoAreYou = function(){//這個也是所謂的closure, 內部函數可以訪問外部函數的變量 var res = "I'm " + this.name + " and I'm a " + this.gender +"."; return res; }; } // 那麼在由Person創建的對象便具有了下面的幾個屬性 Person.prototype.age = 24; Person.prototype.getAge = function(){ return this.age; }; flag = true; if (flag) { var fun = new Person("Tower", "male"); alert(fun.name); alert(fun.gender); alert(fun.whoAreYou()); alert(fun.getAge()); } Person.prototype.salary = 10000; Person.prototype.getSalary = function(){ return this.name + " can earn about " + this.salary + "RMB each month." ; }; // 下面就是最神奇的地方, 我們改變了Person的prototype,而這個改變是在創建fun之後 // 而這個改變使得fun也具有了相同的屬性和方法 // 繼承的意味即此 if (flag) { alert(fun.getSalary()); alert(fun.constructor.prototype.age);//而這個相當於你直接調用 Person.prototype.age alert(Person.prototype.age); }
由此可見,prototype 上的方法和屬性能 動態 增減,而由它創建的對象會 自動繼承 這些成員。
另外,每個對象都有一個 constructor 屬性,指向創建它的函數對象,上例中 fun.constructor 就指向 Person。
那麼問題來了:函數自身聲明的成員和 prototype 上聲明的成員有何差別?
差別如下:
1. 自身聲明的方法和屬性是 靜態的,聲明後再想增改,不會影響已創建的對象,即「繼承」失敗;
2. prototype 上的成員可動態增改,是 動態的,父函數對象一旦聲明相關 prototype 屬性,由其創建的對象會自動繼承。
延續上面的例子:
flag = true; // 函數內部聲明的方法是靜態的,無法傳遞的 Person.school = "ISCAS"; Person.whoAreYou = function(){ return "zhutao"; };//動態更改聲明期的方法,並不會影響由其創建的對象的方法, 即所謂的 靜態 if (flag) { alert(Person.school); alert(fun.school);//輸出的是 "undefined" alert(Person.whoAreYou()); //輸出 zhutao alert(fun.whoAreYou()); // I'm Tower and I'm a male. } Person.prototype.getSalary = function(){ return "I can earn 1000000 USD"; }; if (flag) { alert(fun.getSalary());//已經繼承了改變, 即所謂的 動態 }
既然同時存在自身屬性和 prototype 屬性,對象查找屬性時按什麼順序?
1. 先查函數對象自身的屬性,命中即執行;
2. 若沒找到,再查 prototype 屬性;有兩種結果——找到就執行,否則繼續往父對象的父對象的 prototype 上找,直到命中或抵達 prototype chain 末尾(末尾是 Object 對象)。
這也回答了自身屬性與 prototype 屬性重名時的處理:函數自身的屬性優先。
prototype 的典型示例
用過 jQuery 或 Prototype 庫的朋友應該熟悉 trim 方法。
示例:
String.prototype.trim = function() { return this.replace(/^\s+|\s+$/g, ''); };
用法:
' foo bar '.trim(); // 'foo bar'
但有個問題:較新版本的瀏覽器已在 String 上自帶 trim,我們的定義會覆寫它。其實定義前先做個檢測即可:
if(!String.prototype.trim) { String.prototype.trim = function() { return this.replace(/^\s+|\s+$/g, ''); }; }
原型鏈
JavaScript 中定義或實例化任何對象時,都會被附加一個隱藏的 __proto__ 屬性,原型鏈正是靠它串起來。千萬別直接訪問 __proto__,因為部分瀏覽器並不支持;另外 __proto__ 和對象的 prototype 屬性並不是一回事,各有用途。
怎麼理解?當我們創建 myObject 函數時,其實是創建了一個 Function 類型的對象:
console.log(typeof myObject); // function
Function 是 JavaScript 預定義的對象,它有自己的屬性(如 length、arguments)和方法(如 call、apply),當然也有 __proto__ 以形成原型鏈。也就是說,引擎內部大致有這麼一段:
Function.prototype = { arguments: null, length: 0, call: function() { // secret code }, apply: function(){ // secret code }, ... };
真實引擎當然沒這麼簡單,這裡只是為了說明原型鏈如何運作。
我們定義了一個帶參數 name 的函數 myObject,卻沒給它 length 或 call 等成員,那下面這段為何能跑?
console.log(myObject.length); // 結果:1,是參數的個數
因為定義 myObject 時也給它設了 __proto__ 並賦值為 Function.prototype,所以能像訪問普通屬性那樣訪問 myObject.length——它會沿 __proto__ 原型鏈上溯,最終在 Function 裡找到。
那為何 length 是 1 而非 0?因為 myObject 是 Function 的實例:
console.log(myObject instanceof Function); // true console.log(myObject === Function); // false
實例化時,對象的 __proto__ 會被賦值為其構造者的原型對象(此處即 Function),此時構造器去計算參數個數並改寫 length。
console.log(myObject.__proto__ === Function.prototype); // true
而當我們用 new 創建新實例時,新對象的 __proto__ 會被賦值為 myObject.prototype,因為此時構造函數是 myObject 而非 Function。
var myInstance = new myObject('foo'); console.log(myInstance.__proto__ === myObject.prototype); // true
新對象既能訪問從 Function.prototype 繼承來的 call、apply,也能訪問從 myObject 繼承來的 getName:
console.log(myInstance.getName()); // foo var mySecondInstance = new myObject('bar'); console.log(mySecondInstance.getName()); // bar console.log(myInstance.getName()); // foo
這其實就是把原型對象當藍本,據此創建 N 個新對象。
再看一個多重原型鏈的例子:
// 多重prototype鏈的例子 function Employee(name) { this.name = ""; this.dept = "general"; this.gender = "unknown"; } function WorkerBee() { this.projects = []; this.hasCar = false; } WorkerBee.prototype = new Employee; // 第一層prototype鏈 function Engineer() { this.dept = "engineer"; //覆蓋了 "父對象" this.language = "javascript"; } Engineer.prototype = new WorkerBee; // 第二層prototype鏈 var jay = new Engineer("Jay"); if (flag) { alert(jay.dept); //engineer, 找到的是自己的屬性 alert(jay.hasCar); // false, 搜索到的是自己上一層的屬性 alert(jay.gender); // unknown, 搜索到的是自己上二層的屬性 }
上面示例的對象關係如下:
