[Effective JavaScript 笔记]第50条：迭代方法优于循环

"懒"程序员才是好程序员。复制和粘贴样板代码，一但代码有错误，或代码功能修改，那么程序在修改的时候，程序员需要找到所有相同功能的代码一处处进行修改。这会使人重复发明*，而且在别人看代码的时候无法在更高层次都看待问题的解决方案。太容易陷入细节。

for循环

js中的for循环在进行一些细微变化时，可以引入不同的行为。编程的时候对于边界条件的判断往往会导致一些简单的错误。下面的一些for循环的细微变化导致边界条件的变化。

for(var i=0;i<=n;i++){...}
//包括最后的迭代
for(var i=1;i< n;i++){...}
//忽略第一次迭代
for(var i=n;i>=0;i--){...}
//包括第一次迭代
for(var i=n-1;i > 0;i++){...}
//忽略最后的迭代

在这里都是对终止条件的一个设置。这里可以有很多的方式，可以使终止条件发生错误。
js的闭包是一种为这些模式建立迭代抽象方便的、富有表现力的手法，可以避免重复代码。

ES5中数组方法

其中ES5中提供的数组方法就包含很多。比如

Array.prototype.forEach

比如下面这段对数组的循环。

for(var i=0,n=players.length;i< n;i++){
    players[i].score++;
}

使用数组的迭代方法，可以改写为

players.forEach(function(p){
    p.score++;
});

上面的代码把循环的方式进行抽象，把要执行的具体代码通过函数传递闭包，完成对数组元素的操作及访问。这里消除了终止条件和任何数组索引。

Array.prototype.map

完成对数组的每个元素进行一些操作后建立一个新的数组。

使用循环

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

使用map

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

Array.prototype.filter

计算一个数组建立一个新数组，该数组只包含有数组的一些元素
filter方法需要一个谓词函数，如果元素应该存在于新数组中则返回真值，如果元素应该被剔除则返回假值。例如，可以从价格表中提取出一个特定价格区间的列表。

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

以上的forEach,map,filter三个方法都是ES5中，数组的默认方法。下面实现一个自己的迭代抽象。
例：提取出满足谓词函数的数组的前几个元素，直到不满足的元素终止，不管后面是否有元素满足条件。

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

var prefix=takeWhile([1,2,3,4,26,18,9],function(n){
    return n<10;
});
prefix;//[1, 2, 3, 4]

上面pred函数有两个参数，而下面的回调我们只传入了一个参数。对第二个参数没有进行处理，这里是无所谓的。

猴子补丁

把takeWhile函数添加到Array.prototype中使其成为一个方法。

Array.prototype.takeWhile=function(pred){
    var res=[];
    for(var i=0,n=this.length;i < n;i++){
      if(!pred(this[i],i)){
          break;
      }
      res[i]=this[i];
    }  
    return res;
};
var prefix=[1,2,3,4,26,18,9].takeWhile(function(n){
    return n<10;
});
prefix;//[1, 2, 3, 4]

循环控制流操作

只有一点循环优于迭代，循环可以控制流操作，如break和continue。
例如，使用forEach方法来实现takeWhile函数

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

上面的代码怎么终止该循环的当次执行。

内部异常

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

这样的处理方法，把原本简单的处理变得更加复杂了，不可取。

some,every

有没更简单的方法呢。下面看一下数组提供的用于提前终止循环的方法。some和every。

some方法返回一个布尔值表示其回调对数组的任何一个元素是否返回一个真值。

本人理解：
所有元素，对于传入的函数的判断，有一真则为真。全为假才为假。
相当于所有元素执行函数后取或。

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

every方法返回一个布尔值表示其回调函数是否对所有元素返回一个真值。

本人理解：
所有元素，对于传入的函数的判断，有一假则为假。全为真才为真。
相当于所有元素执行函数后取且。

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

这两个方法都是短路循环。只要产生的结果可以决定最后结果后，就不再执行后面的循环。即some一旦产生一个真值，则立即返回。every一旦产生一个假值，也立即返回。
利用它们的特点，改写takeWhile函数。

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

提示

使用迭代方法替换for循环使得代码可读，并且避免了重复循环控制逻辑
使用自定义的迭代函数来抽象未被标准库支持的常见循环模式
在需要提前终止循环的情况下，仍然推荐使用传统的循环。另外，some和every方法也可用于提前退出