underscore学习笔记—数组函数/Arrays

写在前面：

1.5.2版本，计17个函数

集合函数能在数组、对象和类数组对象，如arguments、NodeList和类似的数据类型上工作，要避免传递一个不固定length属性的对象

1、first（返回数组第一个元素）

_.first(array, [n])

返回数组第一个元素，若存在n，则从数组中第一个元素开始的n个元素返回

_.first([5, 4, 3, 2, 1]);
=> 5

2、initial（返回数组最后一个以外的元素）

_.initial(array, [n])

返回数组中除了最后一个元素外的其他全部元素。若存在n，则排除从最后一个开始的n个元素

_.initial([5, 4, 3, 2, 1]);
=> [5, 4, 3, 2]

3、last（返回数组最后一个元素）

_.last(array, [n])

返回数组最后一个元素，若存在n，则返回最后n个元素

_.last([5, 4, 3, 2, 1]);
=> 1

4、rest（返回数组第一个以外的元素）

_.rest(array, [n])

返回数组中第一个以外的元素，若存在n，则返回除了前n个元素以外的其他元素

_.rest([5, 4, 3, 2, 1]);
=> [4, 3, 2, 1]

5、compact（除错）

_.compact(array)

返回一个除去所有false值得array副本。js中，false、null、0、""、undefined和NaN都是false值

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

6、flatten（除去嵌套）

_.flatten(array, [shallow])

将一个多维数组转换为一维数组。如果传递shallow参数（等于true时），则数组将只能减少一维嵌套

_.flatten([1, [2], [3, [[4]]]]);
=> [1, 2, 3, 4];

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

7、without（除去指定值）

_.without(array, [*values])

返回一个删除所有values值得array副本（使用===做相等判断）

_.without([1, 2, 1, 0, 3, 1, 4], 0, 1);
=> [2, 3, 4]

8、union（合并为值为唯一的数组）

_.union(*arrays)
返回传入的数组并集，按顺序返回，数组元素是唯一的

_.union([1, 2, 3], [101, 2, 1, 10], [2, 1]);
=> [1, 2, 3, 101, 10]

9、intersection（返回数组交集）

_.intersection(*arrays)

返回数组交集，结果中的每个值都存在于每个传入的数组中

_.intersection([1, 2, 3], [101, 2, 1, 10], [2, 1]);
=> [1, 2]

10、difference（除去指定值）

_.difference(array, *others)

与without类似，但是返回值来自参数数组参数后者为数组

_.difference([1, 2, 3, 4, 5], [5, 2, 10]);
=> [1, 3, 4]

11、uniq（数组去重）

_.uniq(array, [isSorted], [iterator])

返回数组去重后的副本，使用全等于判断，如果确定数组已经排序，则给isSorted传递true值函数将执行更快的算法。如果处理对象元素，传参iterator来获取要对比的属性

_.uniq([1, 2, 1, 3, 1, 4]);
=> [1, 2, 3, 4]

12、zip（分组合并）

_.zip(*arrays)

将每个相应位置的arrays的值合并在一起。在合并分开保存的数据时很有用。如果用来处理矩阵嵌套数组时，_.zip.appay可以做类似的效果

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

_.zip.apply(_, arrayOfRowsOfData);
=> arrayOfColumnsOfData

13、object（数组转对象）

_.object(list, [values])

将数组转换对象，传递任何一个单独的[key, value]对的列表，或者一个键的列表和一个值得列表。如果存在重复键，最后一个值将被返回。

_.object(['moe', 'larry', 'curly'], [30, 40, 50]);
=> {moe: 30, larry: 40, curly: 50}

_.object([['moe', 30], ['larry', 40], ['curly', 50]]);
=> {moe: 30, larry: 40, curly: 50}
_.object(['moe', 'larry', 'curly', 'larry'], [30, 40, 50, 60]);
=>{moe: 30, larry: 60, curly: 50}

14、indexOf（查找索引值）

_.indexOf(array, value, [isSorted])

返回value在数组中的索引值，如果不存在则返回-1.若已知数组排序，传递true值给iterator将使用更快算法

_.lastIndexOf([1, 2, 3, 1, 2, 3], 2);
=> 4

15、lastIndexOf（从最后查找索引值）

_.lastIndexOf(array, value, [fromIndex])

返回value在数组中从最后开始的索引值，如果不存在则返回-1.传递fromIndex将从你给定的索引值开始搜索。

_.lastIndexOf([1, 2, 3, 1, 2, 3], 2);
=> 4

16、sortedIndex（确定值在数组的位置）

_.sortedIndex(list, value, [iterator], [context])

使用二分查找确定value在list中的位置序号，value按此序号插入能保持list原有的排序。使用迭代函数，函数将作为排序的依据，包括你传递的value。迭代器也可以是字符串的属性名，比如length

_.sortedIndex([10, 20, 30, 40, 50], 35);
=> 3

var stooges = [{name: 'moe', age: 40}, {name: 'curly', age: 60}];
_.sortedIndex(stooges, {name: 'larry', age: 50}, 'age');
=> 1

17、range（创建整数编号函数）

_.range([start], stop, [step])

一个用来创建整数灵活编号的列表的函数，便于each和map循环。start默认为0，step默认为1，返回一个从start到stop的整数的列表。如果stop<start，则会被认为零长度

_.range(10);
=> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
_.range(1, 11);
=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
_.range(0, 30, 5);
=> [0, 5, 10, 15, 20, 25]
_.range(0, -10, -1);
=> [0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
_.range(0);
=> []