DIV CSS 佈局教程網

JavaScript 對象創建模式(上):從命名空間到鏈式調用
編輯:JavaScript基礎知識     

寫 JavaScript 寫久了會發現,真正拉開代碼品質差距的往往不是語法熟不熟,而是「你把東西放在哪裡、怎麼組織」。本系列要談的九種對象創建模式,本質上都是在回答這個問題。上篇先處理五個基礎但高頻的模式。

模式一:命名空間

全局變量是 JavaScript 裡最廉價也最危險的資源。層層嵌套的對象定義如果全靠手寫,很快就會變成這樣:

var app = app || {};
app.moduleA = app.moduleA || {};
app.moduleA.subModule = app.moduleA.subModule || {};
app.moduleA.subModule.MethodA = function () {
  console.log("print A");
};
app.moduleA.subModule.MethodB = function () {
  console.log("print B");
};

層級一深,這種「|| {}」的守門動作就要重複很多次,可讀性極差。命名空間模式就是把這件事收斂到一個函數裡。

先聲明根對象,三種寫法安全性遞增:

// 不安全:可能直接覆蓋已有的 MYAPP
var MYAPP = {};

// 較安全
if (typeof MYAPP === "undefined") {
  var MYAPP = {};
}

// 最簡潔,也是推薦寫法
var MYAPP = MYAPP || {};

然後實作一個通用的命名空間分配器:

MYAPP.namespace = function (ns_string) {
  var parts = ns_string.split('.'),
      parent = MYAPP,
      i;

  // 開頭寫了 MYAPP 也沒關係,自動忽略
  if (parts[0] === "MYAPP") {
    parts = parts.slice(1);
  }

  for (i = 0; i < parts.length; i += 1) {
    // 這一段還不存在就補一個空對象
    if (typeof parent[parts[i]] === "undefined") {
      parent[parts[i]] = {};
    }
    parent = parent[parts[i]];
  }
  return parent;
};

使用起來非常乾淨,而且回傳值是那一層命名空間本身,可以直接拿去掛方法:

var module2 = MYAPP.namespace('MYAPP.modules.module2');
console.log(module2 === MYAPP.modules.module2); // true

MYAPP.namespace('modules.module51');                            // 可省略 MYAPP 前綴
MYAPP.namespace('once.upon.a.time.there.was.this.long.name');   // 多深都不怕

模式二:定義依賴

模塊或函數若要引用第三方庫,最好在函數開頭就把依賴撈成局部變量。這麼做有兩個好處:一是後續代碼裡不必反覆寫長長的命名空間路徑,二是將來換庫時只需要改動這一行。

var myFunction = function () {
  // 依賴集中宣告在頂部
  var event = YAHOO.util.Event,
      dom = YAHOO.util.dom;

  // 以下就可以直接用 event、dom 這兩個局部變量
};

這個習慣同時也是性能優化:局部變量的查找鏈比全局變量短,在熱路徑上累積起來的差異相當可觀。

模式三:私有屬性與私有方法

JavaScript 語言本身沒有 private 關鍵字,但我們可以用作用域鏈與閉包把變量藏起來,只透過授權方法對外開放。

function Gadget() {
  // 私有成員,外部無法直接觸及
  var name = 'iPod';

  // 公有方法,形成閉包
  this.getName = function () {
    return name;
  };
}

var toy = new Gadget();
console.log(toy.name);     // undefined,name 是私有的
console.log(toy.getName()); // "iPod",只能透過授權方法讀取

另一種常見寫法是用立即執行函數創建私有作用域,再把公有部分掛到外部變量上:

var myobj;
(function () {
  // 自由變量,藏在閉包裡
  var name = "my, oh my";

  // 注意這裡沒有 var,是要暴露到外面的公有部分
  myobj = {
    getName: function () {
      return name;
    }
  };
}());

模式四:Revelation 模式

這個模式同樣為了隱藏私有實現,和 Module 模式思路接近,但風格不同:不是在最後 return 一個對象,而是先在外部宣告變量,再由內部為它賦值。差別在於私有函數可以在同一個閉包內被其他私有函數直接呼叫,而暴露出去的形式則由最後那次賦值決定,頗有一種「揭示」的意味,因此得名。

var myarray;

(function () {
  var astr = "[object Array]",
      toString = Object.prototype.toString;

  function isArray(a) {
    return toString.call(a) === astr;
  }

  function indexOf(haystack, needle) {
    var i = 0,
        max = haystack.length;
    for (; i < max; i += 1) {
      if (haystack[i] === needle) {
        return i;
      }
    }
    return -1;
  }

  // 一次賦值,把所有實現細節都收進閉包
  myarray = {
    isArray: isArray,
    indexOf: indexOf,
    inArray: indexOf   // 同一個私有函數,換個名字再暴露一次
  };
}());

測試時會發現一個有趣的性質:即使外部把 indexOf 設為 null,inArray 依然照常運作,因為它們指向的是同一個閉包內的私有函數引用,彼此獨立於對象上的屬性。

console.log(myarray.isArray([1, 2]));    // true
console.log(myarray.isArray({ 0: 1 }));  // false
console.log(myarray.indexOf(["a", "b", "z"], "z")); // 2

myarray.indexOf = null;
console.log(myarray.inArray(["a", "b", "z"], "z")); // 仍然是 2

模式五:鏈模式

鏈式調用的目的很單純:讓連續的方法呼叫寫成一行,可讀性大幅提升。實作原理也單純得令人愉悅——每個方法做完自己的事,把 this 原樣回傳即可。

var obj = {
  value: 1,
  increment: function () {
    this.value += 1;
    return this;
  },
  add: function (v) {
    this.value += v;
    return this;
  },
  shout: function () {
    console.log(this.value);
  }
};

// 鏈式呼叫
obj.increment().add(3).shout(); // 5

// 當然也可以一朵一朵拆開呼叫
obj.increment();
obj.add(3);
obj.shout();

jQuery 的 .addClass().css().show() 就是這個模式最成功的商業案例。需要提醒的是,鏈式風格會讓中斷點調試變得稍微棘手,而且一旦某個方法回傳了別的值,整條鏈就斷了,所以團隊內部的約定要一致。

小結

這五個模式解決的是最基礎的組織問題:命名空間管住全局污染,依賴聲明讓替換成本變低,閉包帶來信息隱藏,Revelation 模式在隱藏之餘保留了靈活的暴露策略,鏈式則改善了調用體驗。下篇會繼續談函數語法糖、對象常量、沙盒與靜態成員。

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