你不知道的JavaScript--Item17 循环与prototype最后的几点小tips

1、优先使用数组而不是Object类型来表示有顺序的集合

ECMAScript标准并没有规定对JavaScript的Object类型中的属性的存储顺序。

但是在使用for..in循环对Object中的属性进行遍历的时候，确实是需要依赖于某种顺序的。正因为ECMAScript没有对这个顺序进行明确地规范，所以每个JavaScript执行引擎都能够根据自身的特点进行实现，那么在不同的执行环境中就不能保证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;  
}  
report([{ name: "Hank", points: 1110100 },  
{ name: "Steve", points: 1064500 },  
{ name: "Billy", points: 1050200 }]);  
// ?

如果你确实需要保证运行的结果是建立在数据的顺序上，优先使用数组类型来表示数据，而不是直接使用Object类型。同时，也尽量避免使用for..in循环，而使用显式的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;  
}  
report([{ name: "Hank", points: 1110100 },  
{ name: "Steve", points: 1064500 },  
{ name: "Billy", points: 1050200 }]);  
// "1. Hank: 1110100 2. Steve: 1064500 3. Billy: 1050200\n"

另一个特别依赖于顺序的行为是浮点数的计算：

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

在Item 2中，谈到了浮点数的加法操作甚至不能满足交换律：
(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; // ?

当for..in的遍历顺序不一样时，最后得到的total结果也就不一样了，以下是两种计算顺序和其对应的结果：

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

当然，对于浮点数的计算这一类问题，有一个解决方案是使用整型数来表示，比如我们将上面的浮点数首先放大10倍变成整型数据，然后计算结束之后再缩小10倍：

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

2、绝不要向Object.prototype中添加可列举的(Enumerable)属性

如果你的代码中依赖于for..in循环来遍历Object类型中的属性的话，不要向Object.prototype中添加任何可列举的属性。

但是在对JavaScript执行环境进行增强的时候，往往都需要向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"]

一个可行的解决方案是使用函数而不是在Object.prototype上定义新的方法：

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

但是如果你确实需要向Object.prototype上添加新的属性，同时也不希望该属性在for..in循环中被遍历到，那么可以利用ES5环境提供的Object.defineProject方法：

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  
});

以上代码的关键部分就是将enumerable属性设置为false。这样的话，在for..in循环中就无法遍历该属性了。

3、对于数组遍历，优先使用for循环，而不是for..in循环

虽然上个Item已经说过这个问题，但是对于下面这段代码，能看出最后的平均数是多少吗？

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

通过计算，最后的结果应该是88。

但是不要忘了在for..in循环中，被遍历的永远是key，而不是value，对于数组同样如此。因此上述for..in循环中的score并不是期望的98， 74等一系列值，而是0， 1等一系列索引。

所以你也许会认为最后的结果是：
(0 + 1+ …+ 6) / 7 = 21

但是这个答案也是错的。另外一个关键点在于，for..in循环中key的类型永远都是字符串类型，因此这里的+操作符执行的实际上是字符串的拼接操作：

最后得到的total实际上是字符串00123456。这个字符串转换成数值类型后的值是123456，然后再将它除以元素的个数7，就得到了最后的结果：17636.571428571428

所以，对于数组遍历，还是使用标准的for循环最好

4、优先使用遍历方法而非循环

在使用循环的时候，很容易违反DRY(Don’t Repeat Yourself)原则。这是因为我们通常会选择复制粘贴的方法来避免手写一段段的循环语句。但是这样做回让代码中出现大量重复代码，开发人员也在没有意义地”重复造轮子”。更重要的是，在复制粘贴的时候很容易忽视循环中的那些细节，比如起始索引值，终止判断条件等。

比如以下的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

可见在循环的一些细节处理上很容易出错。而利用JavaScript提供的闭包(参见Item 11)，可以将循环的细节给封装起来供重用。实际上，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++;
});

除了对集合对象进行遍历之外，另一种常见的模式是对原集合中的每个元素进行某种操作，然后得到一个新的集合，我们也可以利用forEach方法实现如下：

// 使用for循环
var trimmed = [];
for (var i = 0, n = input.length; i < n; i++) {
    trimmed.push(input[i].trim());
}

// 使用forEach
var trimmed = [];
input.forEach(function(s) {
    trimmed.push(s.trim());
});

但是由于这种由将一个集合转换为另一个集合的模式十分常见，ES5也提供了Array.prototype.map方法用来让代码更加简单和优雅：

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

另外，还有一种常见模式是对集合根据某种条件进行过滤，然后得到一个原集合的子集。ES5中提供了Array.prototype.filter来实现这一模式。该方法接受一个Predicate作为参数，它是一个返回true或者false的函数：返回true意味着该元素会被保留在新的集合中；返回false则意味着该元素不会出现在新集合中。比如，我们使用以下代码来对商品的价格进行过滤，仅保留价格在[min, max]区间的商品：

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

当然，以上的方法是在支持ES5的环境中可用的。在其它环境中，我们有两种选择： 1. 使用第三方库，如underscore或者lodash，它们都提供了相当多的通用方法来操作对象和集合。 2. 根据需要自行定义。

比如，定义如下的方法来根据某个条件取得集合中前面的若干元素：

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]

为了更好的重用该方法，我们可以将它定义在Array.prototype对象上，具体的影响可以参考Item 42。

Array.prototype.takeWhile = function(pred) {
    var result = [];
    for (var i = 0, n = this.length; i < n; i++) {
        if (!pred(this[i], i)) {
            break;
        }
        result[i] = this[i];
    }
    return result;  
};

var prefix = [1, 2, 4, 8, 16, 32].takeWhile(function(n) {
    return n < 10;
}); // [1, 2, 4, 8]

只有一个场合使用循环会比使用遍历函数要好：需要使用break和continue的时候。比如，当使用forEach来实现上面的takeWhile方法时就会有问题，在不满足predicate的时候应该如何实现呢？

function takeWhile(a, pred) {
    var result = [];
    a.forEach(function(x, i) {
        if (!pred(x)) {
            // ?
        }
        result[i] = x;
    });
    return result;
}

我们可以使用一个内部的异常来进行判断，但是它同样有些笨拙和低效：

function takeWhile(a, pred) {
    var result = [];
    var earlyExit = {}; // unique value signaling loop break
    try {
        a.forEach(function(x, i) {
            if (!pred(x)) {
                throw earlyExit;
            }
            result[i] = x;
        });
    } catch (e) {
        if (e !== earlyExit) { // only catch earlyExit
            throw e;
        }
    }
    return result;
}

可是使用forEach之后，代码甚至比使用它之前更加冗长。这显然是存在问题的。对于这个问题，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

这两个方法都是短路方法(Short-circuiting)：只要有任何一个元素在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;
}