DIV CSS 佈局教程網

JavaScript 極簡入門(二):物件、原型與函式的四種呼叫模式
編輯:關於JavaScript     

本文假設你已有其他語言的程式設計經驗,重點放在 JavaScript 中最容易誤解的三個部分:物件的本質、原型鏈、以及 this 的綁定規則。

型別概觀

簡單型別有五種:數字、字串、布林(true/false)、null、undefined。其餘都是物件,包括函式、陣列、正則運算式與物件本身。

提醒:不要完全相信 typeof 的回傳值,例如 typeof null 會得到 "object",這是語言早期留下的歷史包袱。

物件基礎

在 JavaScript 中,物件就是「屬性的集合」,可視為關聯陣列。每個屬性包含:屬性名(必須為字串)與屬性值(除 undefined 外皆可)。

// 用物件字面量建立空物件
var empty_object = {};

var stooge = {
  "first-name": "Jerome",   // 含連字號,必須加引號
  "last-name": "Howard"
};

// 屬性名若是合法識別符,可省略引號
var flight = {
  airline: "Oceanic",
  number: 815,
  departure: { IATA: "SYD", time: "2004-09-22 14:55", city: "Sydney" },
  arrival:   { IATA: "LAX", time: "2004-09-23 10:42", city: "Los Angeles" }
};

屬性存取有兩種寫法,不存在的屬性回傳 undefined:

var owner = { name: "Name5566" };
owner.name;      // "Name5566"
owner["name"];   // "Name5566"
owner.job;       // undefined
owner.job = "coder";

關鍵觀念:物件是「以參照傳遞」而非複製:

var x = {};
var owner = x;
owner.name = "Name5566";
x.name;   // "Name5566",兩者指向同一個物件

屬性可用 delete 移除:delete obj.x;

原型(prototype)

每個物件都被連結到一個原型物件,並能從原型繼承屬性。以物件字面量建立的物件,其原型是 Object.prototype(而它本身沒有原型)。

規則是:讀取屬性時,若自身沒有,就沿原型鏈往上找,直到 Object.prototype;但「修改」屬性時只會作用在自己身上,不會動到原型。這也是為什麼用 for...in 時常需要用 hasOwnProperty 過濾掉繼承來的多餘屬性。

函式也是物件

函式連結到 Function.prototype,並擁有一個 prototype 屬性(型別為物件),其中的 constructor 指回函式本身:

var f = function() {};
typeof f.prototype;             // 'object'
f === f.prototype.constructor;  // true

函式有兩個隱藏屬性:它的上下文與它的程式碼。函式可以放進變數、陣列,可以當參數傳遞,也可以在函式內部定義函式。

var f = function add(a, b) { return a + b; }
console.log(f);   // [Function: add]

function 後面的名稱是可選的,主要用於遞迴呼叫與除錯時的識別;沒有名稱的叫匿名函式。JavaScript 不要求實參與形式參數數量相符——多傳的被忽略,少傳的其值為 undefined;若沒有 return,回傳值就是 undefined。

函式與它所存取的外部變數共同構成閉包,這是 JavaScript 最關鍵的魅力所在。

函式的四種呼叫模式

每次呼叫時,函式會收到兩個額外參數:this 與 arguments。this 的值取決於「怎麼呼叫」,而非「在哪定義」。

1. 方法呼叫模式

函式作為物件屬性,透過 o.m(args) 呼叫時,this 就是 o:

var obj = {
  value: 0,
  increment: function(v) {
    this.value += (typeof v === 'number' ? v : 1);
  }
};
obj.increment();   // this === obj

2. 函式呼叫模式

不屬於任何物件的函式被直接呼叫時,this 會綁到全域物件:

message = 'Hello World';
var p = function() { console.log(this.message); };
p();   // 'Hello World'

這裡藏著一個經典陷阱:

obj = {
  value: 0,
  increment: function() {
    var helper = function() {
      this.value += 1;   // 加到了全域物件上,不是 obj
    };
    helper();            // 以函式模式呼叫
  }
};
obj.increment();
obj.value;   // 仍是 0

解法是在方法內先用一個變數接住 this:

obj = {
  value: 0,
  increment: function() {
    var that = this;
    var helper = function() { that.value += 1; };
    helper();
  }
};
obj.increment();
obj.value;   // 1

(在 ES5 以後,箭頭函式因為不綁定自己的 this,能直接繼承外層的值,是更現代的寫法。)

3. 建構函式呼叫模式

以 new 呼叫的函式被稱為建構函式(慣例上首字大寫)。new 會建立一個連結到該函式 prototype 的新物件,並讓函式內的 this 指向它:

var Test = function(string) { this.message = string; };
var myTest = new Test("Hello World");

4. apply 呼叫模式

apply 的第一個參數指定 this,第二個是參數陣列:

var add = function(a, b) { return a + b; };
var ret = add.apply(null, [3, 4]);   // 7

arguments 與變長參數

呼叫時可存取名為 arguments 的類陣列(不是真正的陣列),內含所有實參,因此能實作變長參數:

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

例外處理

var add = function (a, b) {
  if (typeof a !== 'number' || typeof b !== 'number') {
    throw { name: 'TypeError', message: 'add needs numbers' };
  }
  return a + b;
};

try {
  add("seven");
} catch (e) {
  console.log(e.name + ': ' + e.message);
}

實務上建議丟出真正的 Error 物件(throw new TypeError(...)),才能保有完整的堆疊資訊。

為型別擴充方法

大多數型別都有對應的建構函式(Object、Array、Function、String、Number、Boolean、RegExp),因此可以往其 prototype 上掛方法:

Number.prototype.integer = function() {
  return Math[this < 0 ? 'ceil' : 'floor'](this);
};
(1.1).integer();   // 1

但要謹慎:擴充內建原型會影響整份頁面所有程式碼,若與第三方函式庫命名衝突,排查起來非常痛苦。除 polyfill 之外,盡量不要這麼做。

作用域

JavaScript 需要用函式來建立作用域:

(function() {
  // ...
})();

利用這點可以隱藏不希望外露的變數:

var obj = function() {
  var value = 0;          // 外部無法存取
  return {
    increment: function() { value += 1; },
    getValue:  function() { return value; }
  };
}();

obj.increment();
obj.getValue();   // 1

繼承

建立物件時可以指定其原型:

var o = Object.create({x:1, y:2});

Object.create 定義於 ECMAScript 5,若要在 ES3 環境使用可自行補上:

if (typeof Object.create !== 'function') {
  Object.create = function (o) {
    var F = function () {};
    F.prototype = o;
    return new F();
  };
}

原型式繼承的範例——新物件直接繼承舊物件,不需要「類」的存在:

var myMammal = {
  name: 'Herb the Mammal',
  get_name: function() { return this.name; },
  says: function() { return this.saying || ''; }
};

var myCat = Object.create(myMammal);
myCat.name = 'Henrietta';
myCat.saying = 'meow';
myCat.purr = function(n) {
  var i, s = '';
  for (i = 0; i < n; i += 1) s += (s ? '-' : '') + 'r';
  return s;
};

這種寫法簡單,但無法保護私有成員。若需要私有性,改用模組模式——由函式產生物件,並靠函式作用域把私有資料藏起來:

var mammal = function(spec) {
  var that = {};
  that.get_name = function() { return spec.name; };      // spec.name 外部無法直接存取
  that.says     = function() { return spec.saying || ''; };
  return that;
};

var myMammal = mammal({name: 'Herb'});

var cat = function(spec) {
  spec.saying = spec.saying || 'meow';
  var that = mammal(spec);        // 先構造出 mammal,即完成繼承
  that.purr = function(n) {
    var i, s = '';
    for (i = 0; i < n; i += 1) s += (s ? '-' : '') + 'r';
    return s;
  };
  that.get_name = function() {
    return that.says() + ' ' + spec.name + ' ' + that.says();
  };
  return that;
};

var myCat = cat({name: 'Henrietta'});

在模組模式中,繼承是透過「呼叫建構函式」完成的。若想被子類存取父類的方法,可以加上一個輔助:

Object.prototype.superior = function(name) {
  var that = this, method = that[name];
  return function() { return method.apply(that, arguments); };
};

var coolcat = function (spec) {
  var that = cat(spec), super_get_name = that.superior('get_name');
  that.get_name = function(n) {
    return 'like ' + super_get_name() + ' baby';
  };
  return that;
};

最後補一句現實面的建議:今天的專案幾乎都會用 ES6 以後的 class/extends 語法糖與箭頭函式,that = this 這種繞法已很少需要。但理解上述四種呼叫模式,才能解釋 this 為什麼在某些回呼中「跑掉」——這是除錯時的必備知識。

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