DIV CSS 佈局教程網

JavaScript 的函式、物件建立、封裝、屬性方法與繼承全解析
編輯:關於JavaScript     

JavaScript 的靈活,一部分來自「同一件事有很多種寫法」。但這些寫法並非隨意可換,背後的語意差別往往就是 bug 的根源。以下從函式談到繼承。

一、函式:四種宣告方式的解析時機不同

// 函式定義:命名函式(宣告式)、匿名函式(引用式)

// 宣告式:定義程式碼先於函式執行程式碼被解析
function t1() { dwn("t1"); }
t1();
function t1() { dwn("new t1"); }
t1();

// 引用式:在函式運行中進行動態解析
var t1 = function () { dwn("new new t1"); }
t1();
var t1 = function () { dwn("new new new t1"); }
t1();

// 以上輸出:new t1、new t1、new new t1、new new new t1

很多人預期會看到 t1、new t1…,實際卻不是。關鍵就在那句註解:宣告式的定義程式碼先於執行程式碼被解析。兩個 function t1(){} 相當於對 window.t1 賦值兩次,最後一次覆蓋前一次,所以前兩次呼叫都印出 new t1。而後兩段是引用式,逐行執行、逐行賦值,因此各自印出自己的內容。

匿名函式還有幾種變體:

// 立即執行,最後一對括號用於傳入參數
(function () { ... })();

// new 之後 t1 已經是一個物件
var t1 = new function () {
  var temp = 100;      // 私有成員
  this.temp = 200;     // 公有成員
  return temp + this.temp;
};

alert(typeof t1);      // object
alert(t1.constructor()); // 300

// 用系統內建的 Function 建構式建立函式
var t3 = new Function('var temp = 100; this.temp = 200; return temp + this.temp;');
alert(typeof t3);      // function
alert(t3());           // 300

二、建立物件的三種方式

先理解物件導向的價值:每個模組提供特定功能、彼此獨立,這種模組化帶來極大的多樣性與程式碼重用機會。就像改裝賽車,OO 讓你只需換引擎,不必整台送回原廠。

JavaScript 並非純正的 OO 語言,但透過模擬,繼承、多型、封裝都能做到。

// 1. new Object,逐個加上屬性
var a = new Object();
a.x = 1, a.y = 2;

// 2. 物件直接量(第一種的語法糖)
var b = {x: 1, y: 2};

// 3. 定義類型(類似 C# 中的類)
function Point(x, y) {
  this.x = x;
  this.y = y;
}
var p = new Point(1, 2);

三、封裝:公有與私有

function List() {
  var m_elements = [];   // 私有成員,物件外無法存取
  // 若此處漏掉 var,m_elements 會變成全域變數,外部就能直接存取

  m_elements = Array.apply(m_elements, arguments);

  // 模擬 getter:使用時寫 alist.length
  // 等價於 this.length = function(){ return m_elements.length; }
  this.length = {
    valueOf:  function () { return m_elements.length; },
    toString: function () { return m_elements.length; }
  };

  // 公有方法:alert(alist) 相當於 alert(alist.toString())
  this.toString = function () {
    return m_elements.toString();
  };

  // 公有方法
  this.add = function () {
    m_elements.push.apply(m_elements, arguments);
  };

  // 私有方法:涉及閉包概念
  // var add = function () {
  //   m_elements.push.apply(m_elements, arguments);
  // }
}

var alist = new List(1, 2, 3);
dwn(alist);          // 輸出 1,2,3
dwn(alist.length);   // 輸出 3
alist.add(4, 5, 6);
dwn(alist);          // 輸出 1,2,3,4,5,6
dwn(alist.length);   // 輸出 6

封裝的原理很簡單:var 宣告的變數只存在於建構函式的執行範圍內,而所有 this.xxx 的方法透過閉包參照到它,於是形成「外部看不到、內部拿得到」的效果。

四、四種類型的屬性與方法

// 動態公有類型、靜態公有類型(原型屬性)
function myClass() {
  var p = 100;    // private property
  this.x = 10;    // dynamic public property
}

myClass.prototype.y = 20;   // static public / prototype property
                            // 動態為 myClass 的原型加上屬性,作用於所有已建立的實例
myClass.z = 30;             // static property(類屬性)

var a = new myClass();
dwn(a.p);        // undefined,私有屬性外部讀不到
dwn(a.x);        // 10
dwn(a.y);        // 20,沿原型鏈找到

a.x = 20;
a.y = 40;
dwn(a.x);        // 20
dwn(a.y);        // 40

delete a.x;      // 刪除實例上的 x
delete a.y;      // 刪除實例上的 y
dwn(a.x);        // undefined
dwn(a.y);        // 20 ← 刪掉實例屬性後,原型屬性重新可見
dwn(a.z);        // undefined,類屬性無法透過實例存取
dwn(myClass.z);  // 30

四種類型的行為差異:

  • 私有屬性:外部完全無法存取,只能透過內部的 getter/setter(需手動模擬)。
  • 動態公有屬性:每個實例各持一份副本,互不影響。
  • 原型屬性:所有實例共享唯一副本——這是它省記憶體的原因,也是它危險的原因。
  • 類屬性:不屬於任何實例,只掛在建構函式上。

五、原型(prototype)

成語「照貓畫虎」很貼切:貓是原型,虎是類型。

虎.prototype = 某隻貓;
虎.prototype = new 貓();

因為原型屬性被所有實例共享,其中一個實例改動了原型屬性的值,所有實例讀到的都會變。這點必須時時刻刻記在心裡。

原型鏈的型別關係:

function ClassA() {}
ClassA.prototype = new Object();

function ClassB() {}
ClassB.prototype = new ClassA();

function ClassC() {}
ClassC.prototype = new ClassB();

var obj = new ClassC();
dwn(obj instanceof ClassC);   // true
dwn(obj instanceof ClassB);   // true
dwn(obj instanceof ClassA);   // true
dwn(obj instanceof Object);   // true

帶預設值的 Point 物件:

function Point2(x, y) {
  if (x) this.x = x;
  if (y) this.y = y;
}

// 設定預設值為 0
Point2.prototype.x = 0;
Point2.prototype.y = 0;

var p1 = new Point2();      // 預設 (0,0),括號可省略也不會出錯
var p2 = new Point2(1, 2);

dwn(p1.x + "," + p1.y);     // 0,0
dwn(p2.x + "," + p2.y);     // 1,2

刪除實例屬性後,會回到原型上的初始狀態:

function ClassD() {
  this.a = 100;
  this.b = 200;
  this.c = 300;
}
ClassD.prototype = new ClassD();   // 把原有屬性連同值一起設為原型

ClassD.prototype.reset = function () {   // 刪除所有非原型屬性
  for (var each in this) {
    delete this[each];
  }
};

var d = new ClassD();
dwn(d.a);        // 100
d.a *= 2; d.b *= 2; d.c *= 2;
dwn(d.a);        // 200
dwn(d.b);        // 400
dwn(d.c);        // 600

d.reset();       // 刪掉非原型屬性,全部回到原型
dwn(d.a);        // 100
dwn(d.b);        // 200
dwn(d.c);        // 300

六、繼承的五種模擬手法

1. 構造繼承法

// 定義 Collection 類型
function Collection(size) {
  this.size = function () { return size; };   // 公有方法,可被繼承
}

Collection.prototype.isEmpty = function () {  // 靜態方法,不能被繼承
  return this.size() == 0;
};

// ArrayList 繼承 Collection
function ArrayList() {
  var m_elements = [];                        // 私有成員,不能被繼承
  m_elements = Array.apply(m_elements, arguments);

  this.base = Collection;
  this.base.call(this, m_elements.length);    // 借用父類建構式

  this.add = function () {
    return m_elements.push.apply(m_elements, arguments);
  };
  this.toArray = function () { return m_elements; };
}

ArrayList.prototype.toString = function () {
  return this.toArray().toString();
};

// SortedList 繼承 ArrayList
function SortedList() {
  this.base = ArrayList;
  this.base.apply(this, arguments);

  this.sort = function () {
    var arr = this.toArray();
    arr.sort.apply(arr, arguments);
  };
}

var a = new ArrayList(1, 2, 3);
dwn(a);
dwn(a.size());     // 從 Collection 繼承而來
dwn(a.isEmpty);    // 沒有繼承到 prototype 上的 isEmpty

var b = new SortedList(3, 1, 2);
b.add(4, 0);              // 從 ArrayList 繼承
dwn(b.toArray());         // 從 ArrayList 繼承
b.sort();                 // 自己實作
dwn(b.toArray());
dwn(b.size());            // 從 Collection 繼承

2. 原型繼承法

function Point(dimension) {
  this.dimension = dimension;
}

function Point2D(x, y) {
  this.x = x;
  this.y = y;
}
Point2D.prototype.distance = function () {
  return Math.sqrt(this.x * this.x + this.y * this.y);
};
Point2D.prototype = new Point(2);      // Point2D 繼承 Point

function Point3D(x, y, z) {
  this.x = x;
  this.y = y;
  this.z = z;
}
Point3D.prototype = new Point(3);      // Point3D 也繼承 Point

var p1 = new Point2D(0, 0);
var p2 = new Point3D(0, 1, 2);

dwn(p1.dimension);            // 2
dwn(p2.dimension);            // 3
dwn(p1 instanceof Point2D);   // true
dwn(p1 instanceof Point);     // true
dwn(p2 instanceof Point);     // true

3. 實例繼承法——用來解決前兩種對內建物件的無效

// 構造繼承的局限
function MyDate() {
  this.base = Date;
  this.base.apply(this, arguments);
}
var date = new MyDate();
alert(date.toGMTString);   // undefined,並沒有繼承到 Date 的方法

// 原型繼承也無效
function MyDate() {}
MyDate.prototype = new Date();
var date = new MyDate();
alert(date.toGMTString);   // 不是日期物件,仍然沒有繼承到

// 實例繼承法
function MyDate() {
  var instance = new Date();          // 建立一個真正的日期物件
  instance.printDate = function () {  // 對它擴充方法
    document.write("<p> " + instance.toLocaleString() + "</p> ");
  };
  return instance;                    // 把它作為建構式的回傳值
}

var myDate = new MyDate();
dwn(myDate.toGMTString());   // 成功輸出時間字串,myDate 已是 Date 的實例
myDate.printDate();          // 若沒有 return instance,將無法以下標存取

核心物件之所以無法用前兩種方式繼承,是因為它們不像自訂物件那樣在建構函式裡做賦值或初始化。

4. 拷貝繼承法(不推薦)

Function.prototype.extends = function (obj) {
  for (var each in obj) {
    this.prototype[each] = obj[each];   // 一對一複製屬性
  }                                      // 又慢又容易出問題
};

var Point2D = function () {
  // ……
};
Point2D.extends(new Point());

5. 混合繼承法——實務上最常用

function Point2D(x, y) {
  this.x = x;
  this.y = y;
}

function ColorPoint2D(x, y, c) {
  Point2D.call(this, x, y);   // 構造繼承:呼叫父類建構式
  // 等價於:
  // this.base = Point2D;
  // this.base.call(this, x, y);
  this.color = c;
}

ColorPoint2D.prototype = new Point2D();   // 原型繼承:以 Point2D 物件為原型

混合繼承之所以成為主流,是因為它同時拿到兩邊的優點:用構造繼承保證每個實例都有自己的屬性副本,用原型繼承把方法掛在共享的原型上,避免每次 new 都複製一份函式。

今天寫 ES6,這一切有了統一的語法:

class ColorPoint2D extends Point2D {
  constructor(x, y, c) {
    super(x, y);
    this.color = c;
  }
}

extends 就是「構造繼承 + 原型鏈串接」的語法糖,super 就是 Point2D.call(this, ...)。語法變乾淨了,但底下跑的都是上面這些機制——理解原型,才能解釋為什麼方法該放 prototype 而不是 this,也才能判斷一個屬性改動會不會影響到其他實例。

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