Underscore.js 数组完整参考

Underscore.js 是一个 JavaScript 实用工具库，提供了许多常用的函数和工具方法。在本篇文章中，我们将深入了解 Underscore.js 数组方法的完整参考。

1. 数组创建

_.first(array, [n])

返回数组的前 n 个元素，如果没有传入 n，则返回第一个元素。如果数组为空，则返回 undefined。

_.first([5, 4, 3, 2, 1], 3); // [5, 4, 3]
_.first([], 2); // undefined

_.initial(array, [n])

返回从数组的第一个元素开始，不包含最后 n 个元素的新数组。如果没有传入 n，则返回不包含最后一个元素的新数组。

_.initial([5, 4, 3, 2, 1], 2); // [5, 4, 3]
_.initial([5, 4, 3, 2, 1], 0); // [5, 4, 3, 2]

_.last(array, [n])

返回数组的后 n 个元素，如果没有传入 n，则返回最后一个元素。如果数组为空，则返回 undefined。

_.last([5, 4, 3, 2, 1], 2); // [2, 1]
_.last([], 3); // undefined

_.rest(array, [index])

返回从数组的第 index 个元素开始到最后一个元素的新数组，如果没有传入 index，默认从第一个元素开始。如果 index 大于数组长度，则返回空数组。

_.rest([5, 4, 3, 2, 1], 2); // [3, 2, 1]
_.rest([5, 4, 3, 2, 1], 7); // []

2. 数组遍历

_.each(list, iteratee, [context])

遍历 list 中的每个元素，用 iteratee 函数进行迭代。如果传入 context，则 iteratee 函数在这个 context 上下文中运行。

_.each([1, 2, 3], function(num){ console.log(num); }); // 显示1、2、3
_.each({one: 1, two: 2, three: 3}, function(num, key){ console.log(key); }); // 显示 'one'、'two'、'three'

_.map(list, iteratee, [context])

遍历 list 中的每个元素，用 iteratee 函数进行迭代，返回一个新的数组。如果传入 context，则 iteratee 函数在这个 context 上下文中运行。

_.map([1, 2, 3], function(num){ return num * 3; }); // [3, 6, 9]

_.reduce(list, iteratee, [memo], [context])

迭代 list 中的每个元素，将 iteratee 函数的结果保留在 memo 变量中，最后返回最终的 memo 值。如果没有传入 memo，则从 list 的第一个元素开始迭代，并将第一个元素赋值给 memo。如果传入 context，则 iteratee 函数在这个 context 上下文中运行。

_.reduce([1, 2, 3], function(memo, num){ return memo + num; }, 0); // 6

_.find(list, predicate, [context])

遍历 list 中的每个元素，返回第一个使 predicate 函数返回 true 的元素。如果没找到任何元素，则返回 undefined。如果传入 context，则 predicate 函数在这个 context 上下文中运行。

_.find([1, 2, 3, 4, 5], function(num){ return num % 2 == 0; }); // 2
_.find([1, 3, 5], function(num){ return num % 2 == 0; }); // undefined

_.filter(list, predicate, [context])

遍历 list 中的每个元素，返回一个新的数组，包含使 predicate 函数返回 true 的元素。如果传入 context，则 predicate 函数在这个 context 上下文中运行。

_.filter([1, 2, 3, 4, 5, 6], function(num){ return num % 2 == 0; }); // [2, 4, 6]

_.reject(list, predicate, [context])

遍历 list 中的每个元素，返回一个新的数组，包含使 predicate 函数返回 false 的元素。如果传入 context，则 predicate 函数在这个 context 上下文中运行。

_.reject([1, 2, 3, 4, 5, 6], function(num){ return num % 2 == 0; }); // [1, 3, 5]

_.every(list, [predicate], [context])

遍历 list 中的每个元素，如果 predicate 函数对于所有元素都返回 true，则返回 true。如果某个元素返回 false，则停止遍历并返回 false。如果传入 context，则 predicate 函数在这个 context 上下文中运行。

_.every([1, 2, 3], function(num){ return num % 2 == 0; }); // false
_.every([2, 4, 6], function(num){ return num % 2 == 0; }); // true

_.some(list, [predicate], [context])

遍历 list 中的每个元素，如果 predicate 函数对于任意一个元素都返回 true，则返回 true。如果遍历完所有元素都返回 false，则返回 false。如果传入 context，则 predicate 函数在这个 context 上下文中运行。

_.some([1, 2, 3], function(num){ return num % 2 == 0; }); // true
_.some([1, 3, 5], function(num){ return num % 2 == 0; }); // false

3. 数组转换

_.pluck(list, propertyName)

返回一个新数组，由 list 中每个元素的 propertyName 属性值组成。

var people = [{name: 'Alice', age: 26}, {name: 'Bob', age: 34}];
_.pluck(people, 'name'); // ['Alice', 'Bob']

_.where(list, properties)

返回一个新的数组，包含 list 中所有具有 properties 中列出的属性值相等的对象。如果 properties 中列出的属性值不包含在 list 中的某个对象中，则忽略该对象。

var list = [
  {title: 'JavaScript: The Good Parts', author: 'Douglas Crockford', year: 2008},
  {title: 'JavaScript: The Definitive Guide', author: 'David Flanagan', year: 2011},
  {title: 'JavaScript for Kids', author: 'Nick Morgan', year: 2014}
];
_.where(list, {year: 2011}); // [{title: 'JavaScript: The Definitive Guide', author: 'David Flanagan', year: 2011}]

4. 数组排序

_.sortBy(list, iteratee, [context])

返回按照 iteratee 函数返回结果排序后的新数组。如果传入 context，则 iteratee 函数在这个 context 上下文中运行。

var list = [1, 5, 3, 10, 6];
_.sortBy(list, function(num){ return num; }); // [1, 3, 5, 6, 10]

_.groupBy(list, iteratee, [context])

将 list 分组为多个数组，分组的键是 iteratee 函数返回的结果。如果传入 context，则 iteratee 函数在这个 context 上下文中运行。

_.groupBy([1.3, 2.1, 2.4], function(num){ return Math.floor(num); }); // {1: [1.3], 2: [2.1, 2.4]}

_.countBy(list, iteratee, [context])

返回一个对象，包含 list 中每个元素 iteratee 函数返回结果的计数。

_.countBy([1, 2, 3, 4, 5], function(num){ return num % 2 == 0 ? 'even': 'odd'; }); // {odd: 3, even: 2}

5. 数组其他操作

_.flatten(array, [shallow])

将嵌套的数组展开为一个单一层级的数组。如果传入 shallow，则只展开一层嵌套的数组。

_.flatten([1, [2], [3, [[4]]]]); // [1, 2, 3, 4]
_.flatten([1, [2], [3, [[4]]]], true); // [1, 2, 3, [[4]]]

_.compact(array)

返回一个新数组，其中包含 array 中所有非 falsey 值。

_.compact([0, 1, false, 2, '', 3]); // [1, 2, 3]