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
如果你的代碼依賴 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
});看下面這段代碼,你能說出最後的平均數嗎?
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 循環,細節都被很好地封裝了起來。
以上就是本文的全部內容,希望幫助你更透徹地理解 JavaScript 循環的原理與最佳實踐。