Prototype源码浅析——Enumerable部分(三)

现在来看Enumerable剩下的方法

toArray | size | inspect

inject | invoke | sortBy | eachSlice | inGroupsOf | plunk | zip

 

前面说过map的原理，不管原来的集合是什么，调用map之后返回的结果就是一个数组，其中数组的每一项都是经过interator处理了的，如果不提供interator那么默认使用Prototype.K，此时的作用很明显，返回的结果就是原来集合的数组形式。原来的集合中length属性为多少，返回结果数组的length就是多少。

这个特殊情况被作为一个方法独立出来，叫做toArray:

  function toArray() {
    return this.map();
  }

另一个size方法是返回上面那个数组的长度：

  function size() {
    return this.length;
  }

至于inspect，前面在Object和Strng部分见过好几次了，这里调用Array的inspect方法[Array部分后面分析，不过inspect这个方法太熟悉了，也没必要说了]。

  function inspect() {
    return '[' + this.map(Object.inspect).join(', ') + ']';
  }

另外，对于集合来说，另一个操作是分组。Enumerable中对应的方法是eachSlice 和 inGroupsOf。

先抛开源码，单独来实现这个方法，需要的一个参数是每一个分组的长度（叫做number），如果最后一组长度不够，就保留最后一组的实际长度。

具体实现步骤：

第一、检测number的值，如果number小于1，那么肯定是非法字符，直接返回原来的集合。

第二、将所操作集合转变为数组A，转变方法就是在原来的集合上面调toArray方法。

第三、数组A分组有原生的方法slice，循环调用即可。

按照上面的步骤，可得到下面的实现：

    Enumerable.eachSlice = function(number){
        if(number < 1){ //第一步
            return this;
        }
        var array = this.toArray();//第二步
        var index = 0;
        var results = [];
        while(index < array.length){//第三步
            results.push(array.slice(index,index + number));
            index += number;
        }
        return results;
    };

对应到具体的源码实现中，index += number;这一步被挪到while的条件中，因此，为了保证循环从0开始，index的初始值被设为-number；另外，和其他的方法一样，eachSlice也提供了iterator, context两个参数，作用依旧不变，所以最后的结果变成：

  function eachSlice(number, iterator, context) {
    var index = -number, slices = [], array = this.toArray();
    if (number < 1) return array;
    while ((index += number) < array.length)
      slices.push(array.slice(index, index+number));
    return slices.collect(iterator, context);   //collect就是map
  }

例子：

console.log([1,2,3,4,5].eachSlice(2));//[[1,2],[3,4],[5,6]]

至于inGroupsOf方法，则是对eachSlice的一个补充而已。eachSlice最后一组长度不够，就保留最后一组的实际长度，在inGroupsOf最后一组长度不够，会用指定的填充符填充(默认填充为null)。因此只要提供iterator函数就可以了：

    Enumerable.inGroupsOf = function(number, fillWith) {
      fillWith = typeof fillWith == 'undefined' ? null : fillWith;//源码中这里使用的是Object.isUndefined
      return this.eachSlice(number, function(slice) {
        while(slice.length < number){
            slice.push(fillWith);
        }
        return slice;
      });
    }

下面看inject，先看手册说明：

inject(accumulator, iterator[, context]) -> accumulatedValue

根据参数 iterator 中定义的规则来累计值。首次迭代时，参数 accumulator 为初始值，迭代过程中，iterator 将处理过的值存放在 accumulator 中，并作为下次迭代的起始值，迭代完成后，返回处理过的 accumulator。

这个操作其实前面也遇到过，可以单独用each来实现，看一个数组求和的例子：

    console.dir([1,2,3,4].inject(0,function(sum,n){
        return sum + n;
    }));//10

如果换做each实现，就是：

    var sum = 0;
    [1,2,3,4].each(function(value){
        sum += value;
    })
    console.dir(sum);//10

 

对比上面的实现和源码中的实现，上面的实现中有一个缺陷：sum全局变量，这是不合理的。

所以变形上面的形式，抛弃那个全局变量sum，由于each方法是固定死的，没有办法再改变，所以我们在外层再包装一个方法，并将叠加部分填进去：

    function fn(accumulator,interator,context){
        [1,2,3,4].each(function(value,index){
            accumulator = interator.call(context,accumulator,value,index);
        })
        return accumulator;
    }
    console.dir(fn(0,function(accumulator,value,index){
        accumulator += value;
        return accumulator;
    }));//10

 

看上面的实现，需要注意的一点是，fn中第一个传入的是一个引用类型的变量，由于这一个实现方式：

accumulator = interator.call(context,accumulator,value,index);

那么最后返回的结果是同一个变量，是对最初传入变量的一个引用，这一点是出于性能和效率的考虑，不过有时候可能导致问题，需警惕。

 

接下来是invoke方法，这个方法和each（map）的作用基本一致，唯一的区别是each（map）执行的是外部提供的一个方法，而invoke执行的是集合对象自身本来就存在的方法。因此，invoke的参数有且只需要有一个，就是集合对象的方法名。举个例子，我们将一个数字数组的每一项都转化为字符串：

对比两种实现：

    var array_1 = [1,2,3,4].map(function(value){
        return value.toString();
    });
    console.log('array_1:',array_1);//["1", "2", "3", "4"]
    var array_2 = [1,2,3,4].invoke('toString');
    console.log('array_2:',array_2);//["1", "2", "3", "4"]

由于少了一次闭包的消耗，因此invoke在效率上稍高，而且形式也简洁不少。

具体实现：

  function invoke(method) {
    //var args = $A(arguments).slice(1); //源码实现
    var args  = Array.prototype.slice.call(arguments,1);
    return this.map(function(value) {
      return value[method].apply(value, args);
    });
  }

 

plunk方法比较简单，获取所有元素的同一个属性的值，并返回相应的数组。这个方法显然是针对普通对象来的，数组的话没有什么属性好取的：

  function pluck(property) {
    var results = [];
    this.each(function(value) {
      results.push(value[property]);
    });
    return results;
  }

 

源码好理解，给个例子就行：

['hello', 'world', 'my', 'is', 'xesam'].pluck('length')// [5, 5, 2, 3, 5]

 

另一个在其他脚本里面常见的方法是zip，这个方法不是很好理解：

zip(Sequence...[, iterator = Prototype.K]) -> Array

将多个（两个及以上）序列按照顺序配对合并（想像一下拉链拉上的情形）为一个包含一序列元组的数组。 元组由每个原始序列的具有相同索引的元素组合而成。如果指定了可选的 iterator 参数，则元组由 iterator 指定的函数生成。 
我们先不考虑iterator ，来第一个实现：

    function zip(){
        var array_1 = [1,2,3];
        var array_2 = ['a','b','c'];
        var array_3 = ['x','y','z'];
        var result = [array_1].concat([array_2,array_3]);//[[1,2,3],['a','b','c'],['x','y','z']]
        return array_1.map(function(value,index){
            return result.pluck(index);
        })
    }
    console.log(zip());//[[1,'a','x'],[2,'b','y'],[3,'c','z']]

改为Enumerable方法的形式就是：

    function zip(){
        var result = [this].concat(Array.prototype.slice.call(arguments,1));
        return this.map(function(value,index){
            return result.pluck(index);
        })
    }
    console.log([1,2,3].zip(['a','b','c'],['x','y','z']));////[[1,'a','x'],[2,'b','y'],[3,'c','z']]

加上interator处理之后就是：

    function zip(){
        var args = Array.prototype.slice.call(arguments,0);
        var interator = function(x){ return x;} //Prototype.K
        if(args[args.length - 1].constructor == Function){
            interator = args.pop();
        }
        var result = [this].concat(Array.prototype.slice.call(arguments,1));
        return this.map(function(value,index){
            return interator.call(result.pluck(index));
        })
    }

 

 

转载请注明来自小西山子【http://www.cnblogs.com/xesam/】

本文地址：http://www.cnblogs.com/xesam/archive/2012/01/19/2326142.html