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;

  };

巴特西

underscore arrays

最新文章

热门文章