DIV CSS 佈局教程網

JavaScript 循環使用指南:從 for-in 到遍歷方法的最佳實踐
編輯:關於JavaScript     

一、表示有序集合時,優先用陣列而非 Object

ECMAScript 標準並未規定 Object 型別中屬性的存儲順序。然而使用 for..in 遍歷屬性時,卻又依賴某種順序。正因為標準沒有明確規範,各個引擎可以按自身特點實現,導致 for..in 在不同環境下的行為不一致。

例如以下代碼調用 report 時的結果就是不確定的:

function report(highScores) {
  var result = "";
  var i = 1;
  for (var name in highScores) { // unpredictable order
    result += i + ". " + name + ": " + highScores[name] + "\n";
    i++;
  }
  return result;
}

如果你確實需要保證結果建立在資料順序上,請優先用陣列表示資料,並改用顯式的 for 循環:

function report(highScores) {
  var result = "";
  for (var i = 0, n = highScores.length; i < n; i++) {
    var score = highScores[i];
    result += (i + 1) + ". " + score.name + ": " + score.points + "\n";
  }
  return result;
}

另一個高度依賴順序的場景是浮點數計算:

var ratings = { "Good Will Hunting": 0.8, "Mystic River": 0.7, "21": 0.6, "Doubt": 0.9 };

浮點數加法甚至不滿足交換律:(0.1 + 0.2) + 0.3 與 0.1 + (0.2 + 0.3) 的結果分別是 0.600000000000001 和 0.6。因此浮點運算更不能依賴任意順序:

var total = 0, count = 0;
for (var key in ratings) { // unpredictable order
  total += ratings[key];
  count++;
}
total /= count;

遍歷順序不同,最終 total 也不同:

(0.8 + 0.7 + 0.6 + 0.9) / 4 // 0.75
(0.6 + 0.8 + 0.7 + 0.9) / 4 // 0.7499999999999999

解決辦法之一是改用整數運算,先放大再縮小:

(8 + 7 + 6 + 9) / 4 / 10 // 0.75
(6 + 8 + 7 + 9) / 4 / 10 // 0.75

二、絕不要向 Object.prototype 添加可枚舉屬性

如果你的代碼依賴 for..in 遍歷屬性,就不要向 Object.prototype 添加任何可枚舉屬性。然而增強執行環境時,我們常想給原型掛新方法,例如:

Object.prototype.allKeys = function() {
  var result = [];
  for (var key in this) { result.push(key); }
  return result;
};

結果卻是:

({ a: 1, b: 2, c: 3 }).allKeys(); // ["allKeys","a","b","c"]

可行的方案是改用獨立函數:

function allKeys(obj) {
  var result = [];
  for (var key in obj) { result.push(key); }
  return result;
}

若你確實需要往原型上加屬性,又不希望它被 for..in 遍歷到,可用 ES5 的 Object.defineProperty,把 enumerable 設為 false:

Object.defineProperty(Object.prototype, "allKeys", {
  value: function() {
    var result = [];
    for (var key in this) { result.push(key); }
    return result;
  },
  writable: true,
  enumerable: false,
  configurable: true
});

三、遍歷陣列時,優先用 for 而非 for..in

看下面這段代碼,你能說出最後的平均數嗎?

var scores = [98, 74, 85, 77, 93, 100, 89];
var total = 0;
for (var score in scores) { total += score; }
var mean = total / scores.length;

期望結果是 88,但 for..in 遍歷的是 key 而非 value,所以 score 拿到的是索引 0、1、2……;更關鍵的是 key 永遠是字串型別,這裡的 + 實際是字串拼接,total 最終變成 "00123456",轉數值後是 123456,再除以 7,得到 17636.571428571428。所以遍歷陣列,還是用標準 for 循環最穩妥。

四、優先使用遍歷方法而非循環

寫循環時很容易違反 DRY 原則,因為我們習慣複製粘貼,導致大量重複代碼,還容易忽略起止索引等細節。比如下面這些 for 循環都存在這樣的問題(設 n 為長度):

for (var i = 0; i <= n; i++) { ... } // 終止條件錯誤,應為 i < n
for (var i = 1; i < n; i++) { ... }   // 起始變量錯誤,應為 i = 0
for (var i = n; i >= 0; i--) { ... }  // 起始變量錯誤,應為 i = n - 1
for (var i = n - 1; i > 0; i--) { ... } // 終止條件錯誤,應為 i >= 0

借助閉包可以把循環細節封裝起來重用。ES5 提供了不少現成方法,最簡單的就是 Array.prototype.forEach:

// 使用 for 循環
for (var i = 0, n = players.length; i < n; i++) { players[i].score++; }
// 使用 forEach
players.forEach(function(p) { p.score++; });

把一個集合轉換為另一個集合的模式也很常見,可用 map:

var trimmed = input.map(function(s) { return s.trim(); });

而按條件過濾得到子集,則可用 filter,它接受一個返回 true/false 的 predicate:

listings.filter(function(listing) {
  return listing.price >= min && listing.price <= max;
});

以上方法需 ES5 環境支持。在其他環境下可選擇:1. 使用 underscore、lodash 等第三方庫;2. 自行定義。例如實現一個 takeWhile:

function takeWhile(a, pred) {
  var result = [];
  for (var i = 0, n = a.length; i < n; i++) {
    if (!pred(a[i], i)) { break; }
    result[i] = a[i];
  }
  return result;
}
var prefix = takeWhile([1, 2, 4, 8, 16, 32], function(n) { return n < 10; }); // [1,2,4,8]

只有一個場景循環會優於遍歷函數:需要使用 break 和 continue 時。因為 forEach 無法提前終止,若硬要用內部異常來模擬,反而更笨拙低效:

function takeWhile(a, pred) {
  var result = [];
  var earlyExit = {};
  try {
    a.forEach(function(x, i) {
      if (!pred(x)) { throw earlyExit; }
      result[i] = x;
    });
  } catch (e) {
    if (e !== earlyExit) { throw e; }
  }
  return result;
}

對此,ES5 提供了 some 和 every 兩個短路方法:

[1, 10, 100].some(function(x) { return x > 5; }); // true
[1, 10, 100].some(function(x) { return x < 0; }); // false
[1, 2, 3, 4, 5].every(function(x) { return x > 0; }); // true
[1, 2, 3, 4, 5].every(function(x) { return x < 3; }); // false

只要任一元素使 some 的 predicate 返回 true,some 就返回;只要任一元素使 every 的 predicate 返回 false,every 就返回 false。於是 takeWhile 可優雅改寫為:

function takeWhile(a, pred) {
  var result = [];
  a.every(function(x, i) {
    if (!pred(x)) { return false; } // break
    result[i] = x;
    return true; // continue
  });
  return result;
}

這其實就是函數式編程的思想——很少看到顯式的 for/while 循環,細節都被很好地封裝了起來。

五、總結

  • 使用 for..in 時不要依賴遍歷順序。
  • 用 Object 保存資料時,確保資料是無序的。
  • 需要有序集合時,用陣列而非 Object。
  • 避免向 Object.prototype 添加任何屬性。
  • 確有必要時,考慮用獨立函數替代原型方法。
  • 用 Object.defineProperty 添加不被 for..in 遍歷的屬性。
  • 遍歷陣列時用標準 for 循環,而非 for..in。
  • 必要時預先緩存陣列長度以提升效能。
  • 用 forEach、map 等遍歷方法讓代碼更清晰。
  • 對重複出現的循環進行抽象,可借助第三方庫或自行實現。
  • 顯式循環在需要 break/continue 時仍有價值,也可用 some/every。

以上就是本文的全部內容,希望幫助你更透徹地理解 JavaScript 循環的原理與最佳實踐。

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