DIV CSS 佈局教程網

JavaScript 對象創建模式(下):語法糖、常量、沙盒與靜態成員
編輯:JavaScript基礎知識     

上一篇我們梳理了五種基礎的對象創建手法,本篇接著往下走,談四個實戰價值很高的進階模式。它們解決的問題各不相同:有的讓 API 寫起來更順手,有的用來鎖住不該被改動的值,有的負責隔離互不干擾的運行環境,最後一個則把「類級別」的狀態從實例中剝離出來。

模式六:函數語法糖

所謂語法糖,指的是在不改變語言本身的情況下,用一層薄封裝讓代碼寫起來更甜、更短。這裡的做法是給 Function.prototype 掛一個 method 方法,之後就能以鏈式風格往構造函數的原型上批量掛方法。

if (typeof Function.prototype.method !== "function") {
  Function.prototype.method = function (name, implementation) {
    this.prototype[name] = implementation;
    return this;
  };
}

定義的時候變成一行接一行的宣告:

var Person = function (name) {
  this.name = name;
}
.method('getName', function () {
  return this.name;
})
.method('setName', function (name) {
  this.name = name;
  return this;
});

驗證一下,注意 setName 回傳了 this,所以能直接接著呼叫 getName:

var a = new Person('Adam');
console.log(a.getName());                // 'Adam'
console.log(a.setName('Eve').getName()); // 'Eve'

要注意的是,直接擴充內建原型屬於侵入性操作,在多人協作或引入第三方庫的專案裡容易撞名,實務上更推薦把這個方法掛在自己的工具命名空間上。

模式七:對象常量

JavaScript 沒有真正的 const 級別的對象成員保護(在 ES5 時代更是如此),但我們可以用閉包把值藏起來,只對外開放 set、get、isDefined 三個閘門,並在 set 裡判斷「已存在則拒絕覆寫」,從而模擬出常量語義。

var constant = (function () {
  var constants = {},
      ownProp = Object.prototype.hasOwnProperty,
      // 只允許這三種基本類型
      allowed = {
        string: 1,
        number: 1,
        boolean: 1
      },
      prefix = (Math.random() + "_").slice(2);

  return {
    set: function (name, value) {
      if (this.isDefined(name)) {
        return false;
      }
      if (!ownProp.call(allowed, typeof value)) {
        return false;
      }
      constants[prefix + name] = value;
      return true;
    },
    isDefined: function (name) {
      return ownProp.call(constants, prefix + name);
    },
    get: function (name) {
      if (this.isDefined(name)) {
        return constants[prefix + name];
      }
      return null;
    }
  };
}());

這裡有兩個細節值得留意:一是只接受字串、數字、布林三種原始值,避免有人塞進一個物件之後又偷偷改它的內部屬性;二是用隨機前綴拼在屬性名前面,降低與其他代碼偶然撞名的機率。

console.log(constant.isDefined("maxwidth")); // false
console.log(constant.set("maxwidth", 480));  // true
console.log(constant.isDefined("maxwidth")); // true
console.log(constant.set("maxwidth", 320));  // false(第二次設定被拒絕)
console.log(constant.get("maxwidth"));       // 480,原值仍在

模式八:沙盒模式

沙盒模式為一個或多個模塊提供彼此隔離的上下文環境。舉例來說,某個庫裡有 event、dom、ajax 三個模塊,一次只挑其中兩個組裝出的環境,跟三個全載入的環境互不干擾,也不會污染全局命名空間。

function Sandbox() {
  // 把 arguments 轉成真陣列
  var args = Array.prototype.slice.call(arguments),
      // 最後一個參數是回呼
      callback = args.pop(),
      // 其餘參數是要載入的模塊名
      modules = (args[0] && typeof args[0] === "string") ? args : args[0],
      i;

  // 允許省略 new
  if (!(this instanceof Sandbox)) {
    return new Sandbox(modules, callback);
  }

  this.a = 1;
  this.b = 2;

  // 沒指定模塊或傳入 "*",就視為載入全部
  if (!modules || modules == '*') {
    modules = [];
    for (i in Sandbox.modules) {
      if (Sandbox.modules.hasOwnProperty(i)) {
        modules.push(i);
      }
    }
  }

  // 逐一初始化所需模塊
  for (i = 0; i < modules.length; i += 1) {
    Sandbox.modules[modules[i]](this);
  }

  callback(this);
}

Sandbox.prototype = {
  name: "My Application",
  version: "1.0",
  getName: function () {
    return this.name;
  }
};

接著註冊各個模塊,每個模塊都是一個接收沙盒實例的函數,只往上面掛自己那組方法:

Sandbox.modules = {};

Sandbox.modules.dom = function (box) {
  box.getElement = function () {};
  box.getStyle = function () {};
  box.foo = "bar";
};

Sandbox.modules.event = function (box) {
  box.attachEvent = function () {};
  box.detachEvent = function () {};
};

Sandbox.modules.ajax = function (box) {
  box.makeRequest = function () {};
  box.getResponse = function () {};
};

三種呼叫方式,三種互不重疊的環境:

Sandbox(['ajax', 'event'], function (box) {
  console.log(typeof box.foo); // undefined,沒載入 dom
});

Sandbox('ajax', 'dom', function (box) {
  console.log(typeof box.attachEvent); // undefined,沒載入 event
});

Sandbox('*', function (box) {
  console.log(box); // 三個模塊的方法都在
});

模式九:靜態成員

靜態成員就是掛在函數或對象本身、而非原型上的屬性,可以分成公有與私有兩類,概念上等同於 C#、Java 裡的 public static 與 private static。

公有靜態成員

var Gadget = function () {};

// 公有靜態方法
Gadget.isShiny = function () {
  return "you bet";
};

// 原型上的實例方法
Gadget.prototype.setPrice = function (price) {
  this.price = price;
};

console.log(Gadget.isShiny()); // "you bet"

var iphone = new Gadget();
iphone.setPrice(500);

// 靜態方法與實例方法各自獨立
console.log(typeof Gadget.setPrice); // "undefined"
console.log(typeof iphone.isShiny);  // "undefined"

如果確實想讓兩邊共用同一份實現,把靜態方法指派到原型上即可:

Gadget.prototype.isShiny = Gadget.isShiny;
console.log(iphone.isShiny()); // "you bet"

私有靜態成員

私有靜態靠閉包實現。第一種寫法是把計數器放在 IIFE 的閉包裡,讓返回的構造函數直接操作它:

var Gadget = (function () {
  var counter = 0; // 私有靜態變量

  return function () {
    console.log(counter += 1);
  };
}());

new Gadget(); // 1
new Gadget(); // 2
new Gadget(); // 3

每次都是新實例,數字卻持續遞增,說明 counter 確實是所有實例共享的一份。第二種寫法多繞一層,透過原型上的授權方法把私有值讀出來:

var Gadget = (function () {
  var counter = 0,
      NewGadget;

  NewGadget = function () {
    counter += 1;
  };

  // 授權方法:唯一能看到私有變量的窗口
  NewGadget.prototype.getLastId = function () {
    return counter;
  };

  return NewGadget;
}());

new Gadget().getLastId(); // 1
new Gadget().getLastId(); // 2
new Gadget().getLastId(); // 3

小結

上下兩篇合起來正好是九種對象創建模式:命名空間、依賴聲明、私有屬性與方法、Revelation 模式、鏈式調用、函數語法糖、對象常量、沙盒、靜態成員。它們沒有高低優劣之分,只有適用場景的差別——寫庫的時候偏愛沙盒與命名空間,寫業務代碼時鏈式與語法糖更常見。真正的功力在於判斷當前問題屬於哪一類,然後挑最合手的那把螺絲刀。

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