underscore arrays

1、_.first():返回array（数组）的第一个元素。传递 n参数将返回数组中从第一个元素开始的n个元素

_.first = _.head = _.take = function(array, n, guard) {
　　//n == null-->array[0];
　　//n != null;guard == ture;-->array[0]
　　//n != null;guard == false;-->返回前n个元素
    return (n != null) && !guard ? slice.call(array, 0, n) : array[0];
  };

2、_.initial():返回数组中除了最后一个元素外的其他全部元素。 在arguments对象上特别有用。传递 n参数将从结果中排除从最后一个开始的n个元素

_.initial = function(array, n, guard) {
　　//n == null--1;
　　//n != null;guard == true--1
　　//n != null;guard != true--n
    return slice.call(array, 0, array.length - ((n == null) || guard ? 1 : n));
  };

//倒序指定的n个元素
slice.call(array, Math.max(array.length-n, 0));

3、_.last():返回array（数组）的最后一个元素。传递 n参数将返回数组中从最后一个元素开始的n个元素，跟first相反

_.last = function(array, n, guard) {
    if ((n != null) && !guard) {
      return slice.call(array, Math.max(array.length - n, 0));
    } else {
      return array[array.length - 1];
    }
  };

4、_.rest():返回数组中除了第一个元素外的其他全部元素。传递 index 参数将返回除了第一个元素到第index元素以外剩余的所有元素，会输出index个元素，跟_.initail相反。underscore不同版本，会函数的定义都不同。

_.rest = _.tail = function(array, index, guard) {
   //guard=true,index无效；slice()输出包含start 
　　return slice.call(array, (index == null) || guard ? 1 : index);
  };

5、_.compact:返回能被转为true的元素　filter返回满足验证的元素

_.compact = function(array) {
    return _.filter(array, function(value){ return !!value; });
  };

6、_.flatten:多维数组转为一维数组　reduce对元素进行迭代，迭代器返回memo，shallow参数用于控制合并深度, 当shallow为true时, 只合并第一层, 默认进行深层合并

_.flatten = function(array, shallow) {
    return _.reduce(array, function(memo, value) {
      //shallow=true,concat value:链接两个或多个数组
      if (_.isArray(value)) return memo.concat(shallow ? value : _.flatten(value));
      //value为值，数组自增赋值
      memo[memo.length] = value;
      return memo;
    }, []);
  };

7、_.without():返回一个删除所有values值的 array副本。与_.difference类似；前者的第二参数为元素，后者的第二参数为数组

_.without = function(array) {
　　 // slice.call(arguments, 1)返回从第二个开始的所有参数
    return _.difference(array, slice.call(arguments, 1));
  };

8、_.uniq():返回 array去重后的副本, 使用 === 做相等测试.
如果您确定 array 已经排序, 那么给 isSorted 参数传递 true值, 此函数将运行的更快的算法.

_.uniq = _.unique = function(array, isSorted, iterator) {
    //如何判断第二个参数是isSorted还是iterator，先判断iterator是否存在。
    //如果iterator存在，则会根据它创建一个新的数组，以它做对比
    var initial = iterator ? _.map(array, iterator) : array;
    var results = [];
    //length=2,则一定有序
    if (array.length < 3) isSorted = true;
    //把数组元素归为统一的值
    _.reduce(initial, function (memo, value, index) {
      //isSorted=true:当前元素与最后一个元素比较：如果不相等的话，有可能跟之前的元素相等呀（已经是有序了，所以相等的都是相邻的）
      //isSorted=false:使用include来检查
      if (isSorted ? _.last(memo) !== value || !memo.length : !_.include(memo, value)) {
        //memo存得时iterator的值
        memo.push(value);
        //results存的是array的值
        results.push(array[index]);
      }
      return memo;
    }, []);
    return results;
  };

9、_.union():与uniq方法作用一致, 不同之处在于union允许在参数中传入多个数组

_.union = function() {
    //true：只合并一层
    return _.uniq(_.flatten(arguments, true));
  };

10、_.intersection()：获取多个数组的交集元素；

_.intersection = _.intersect = function(array) {
    var rest = slice.call(arguments, 1);
    //filter：满足条件的返回
    //先对array去重,uniq只会处理第一个array
    //rest是剩余的，需要比较的
    return _.filter(_.uniq(array), function(item) {
      return _.every(rest, function(other) {
        return _.indexOf(other, item) >= 0;
      });
    });
  };

11、_.difference():返回当前数组中与指定数据不相等的差异数据,第二个参数为array，

_.difference = function(array) {
　　//只合并一层
    var rest = _.flatten(slice.call(arguments, 1), true);
    return _.filter(array, function(value){ return !_.include(rest, value); });
  };

12、_.zip():将每个数组的相同位置的数据作为一个新的二维数组返回, 返回的数组长度以传入参数中最大的数组长度为准, 其它数组的空白位置使用undefined填充，zip方法应该包含多个参数, 且每个参数应该均为数组

_.zip(['moe', 'larry', 'curly'], [30, 40, 50], [true, false, false]);
=> [["moe", 30, true], ["larry", 40, false], ["curly", 50, false]] 

_.zip = function() {
    var args = slice.call(arguments);
    //pluck:获取对象数组的属性值
    var length = _.max(_.pluck(args, 'length'));
    var results = new Array(length);
    //arguments都是数组
    for (var i = 0; i < length; i++) results[i] = _.pluck(args, "" + i);
    return results;
  }; 

13、_.indexof():搜索一个元素在数组中首次出现的位置, 如果元素不存在则返回 -1,搜索时使用 === 对元素进行匹配 

_.indexOf = function(array, item, isSorted) {
	if (array == null) return -1;
	var i, l;
	if (isSorted) {
	  i = _.sortedIndex(array, item);
　　　　　　//写的真好，以后不用if了
	  return array[i] === item ? i : -1;
	}
	if (nativeIndexOf && array.indexOf === nativeIndexOf) return array.indexOf(item);
	for (i = 0, l = array.length; i < l; i++) if (i in array && array[i] === item) return i;
	return -1;
};

14、_.lastIndexOf():返回一个元素在数组中最后一次出现的位置, 如果元素不存在则返回 -1,搜索时使用 === 对元素进行匹配,与indexof相反

_.lastIndexOf = function(array, item) {
    if (array == null) return -1;
    if (nativeLastIndexOf && array.lastIndexOf === nativeLastIndexOf) return array.lastIndexOf(item);
    var i = array.length;
    while (i--) if (i in array && array[i] === item) return i;
    return -1;
  };

15、_.range():创建数组，内容为连续数字

_.range = function(start, stop, step) {
    if (arguments.length <= 1) {
      //如果start=undefined，则stop为0；如果start不为undefined，则stop=start
      stop = start || 0;
      start = 0;
    }
    step = arguments[2] || 1;

    var len = Math.max(Math.ceil((stop - start) / step), 0);
    var idx = 0;
    var range = new Array(len);

    while(idx < len) {
      range[idx++] = start;
      start += step;
    }

    return range;
  };