数组函数(Array Functions)
注: 所有的数组函数也可以用于 arguments (参数)对象。 但是,Underscore 函数不能用于稀疏("sparse" )数组。
First
_.first(array, [n]) Aliases: head, take
返回array (数组)的第一个元素。传递 n参数将返回数组中从第一个元素开始的n个元素(愚人码头注:返回数组中前 n 个元素.)。
_.first([5, 4, 3, 2, 1]);
=> 5
Initial
_.initial(array, [n])
返回数组中除了最后一个元素外的其他全部元素。 在arguments对象上特别有用。传递 n参数将从结果中排除从最后一个开始的n个元素(愚人码头注:排除数组后面的 n 个元素)。
_.initial([5, 4, 3, 2, 1]);
=> [5, 4, 3, 2]
Last
_.last(array, [n])
返回array(数组)中最后一个元素。传递 n参数将返回数组中从最后一个元素开始的n个元素(愚人码头注:返回数组里的后面的n个元素)。
_.last([5, 4, 3, 2, 1]);
=> 1
Rest
_.rest(array, [index]) Aliases: tail, drop
返回数组中除了第一个元素外的其他全部元素。传递 index 参数将返回从index开始的剩余所有元素 。
_.rest([5, 4, 3, 2, 1]);
=> [4, 3, 2, 1]
Flatten
_.flatten(array, [shallow])
将一个嵌套多层的数组 array(数组) (嵌套可以是任何层数)转换为只有一层的数组。 如果你传递 shallow参数,数组将只减少一维的嵌套。
_.flatten([1, [2], [3, [[4]]]]); => [1, 2, 3, 4]; _.flatten([1, [2], [3, [[4]]]], true); => [1, 2, 3, [[4]]];
without
_.without(array, *values)
返回一个删除所有values值后的 array副本。(愚人码头注:使用===表达式做相等测试。)
_.without([1, 2, 1, 0, 3, 1, 4], 0, 1);
=> [2, 3, 4]
union
_.union(*arrays)
返回传入的 arrays(数组)并集:按顺序返回,返回数组的元素是唯一的,可以传入一个或多个 arrays (数组)。
_.union([1, 2, 3], [101, 2, 1, 10], [2, 1]);
=> [1, 2, 3, 101, 10]
intersection
_.intersection(*arrays)
返回传入 arrays(数组)交集。结果中的每个值是存在于传入的每个arrays(数组)里。
_.intersection([1, 2, 3], [101, 2, 1, 10], [2, 1]);
=> [1, 2]
difference
_.difference(array, *others)
类似于without,但返回的值来自array参数数组,并且不存在于other 数组。
_.difference([1, 2, 3, 4, 5], [5, 2, 10]);
=> [1, 3, 4]
uniq
_.uniq(array, [isSorted], [iteratee]) Alias: unique
返回 array去重后的副本, 使用 === 做相等测试. 如果您确定 array 已经排序, 那么给 isSorted 参数传递 true值, 此函数将运行的更快的算法. 如果要处理对象元素, 传递 iteratee函数来获取要对比的属性。
_.uniq([1, 2, 1, 4, 1, 3]);
=> [1, 2, 4, 3]
zip
_.zip(*arrays)
将每个 arrays 中相应位置的值合并在一起。 当您有通过匹配数组索引进行协调的独立数据源时,这非常有用。 结合 apply 一起使用传入一个二维数组。 如果你用来处理矩阵嵌套数组时,则可以使用它来转换矩阵。
_.zip(['moe', 'larry', 'curly'], [30, 40, 50], [true, false, false]); => [["moe", 30, true], ["larry", 40, false], ["curly", 50, false]]
unzip
_.unzip(array)
与zip功能相反的函数,给定若干arrays,返回一串联的新数组,其第一元素个包含所有的输入数组的第一元素,其第二包含了所有的第二元素,依此类推。
_.unzip([["moe", 30, true], ["larry", 40, false], ["curly", 50, false]]); => [['moe', 'larry', 'curly'], [30, 40, 50], [true, false, false]]
object
_.object(list, [values])
将数组转换为对象。传递任何一个单独[key, value]对的列表,或者一个键的列表和一个值得列表。成对(Pairs)传递 则是 pairs 的反函数。 如果存在重复键,最后一个值将被返回。
_.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}
chunk
_.chunk(array, length)
将 array 分成多个数组,每个数组包含length 或更少的项。
var partners = _.chunk(_.shuffle(kindergarten), 2); => [["Tyrone", "Elie"], ["Aidan", "Sam"], ["Katrina", "Billie"], ["Little Timmy"]]
indexOf
_.indexOf(array, value, [isSorted])
返回value在该 array 中的索引值,如果value不存在 array中就返回-1。使用原生的indexOf 函数,除非它失效。如果您正在使用一个大数组,你知道数组已经排序,传递true给isSorted将更快的用二进制搜索..,或者,传递一个数字作为第三个参数,为了在给定的索引的数组中寻找第一个匹配值。
_.indexOf([1, 2, 3], 2);
=> 1
lastIndexOf
_.lastIndexOf(array, value, [fromIndex])
返回value在该 array 中的从最后开始的索引值,如果value不存在 array中就返回-1。传递fromIndex将从你给定的索性值开始搜索。
_.lastIndexOf([1, 2, 3, 1, 2, 3], 2);
=> 4
sortedIndex
_.sortedIndex(array, value, [iteratee], [context])
使用二分查找确定value在list中的位置序号,value按此序号插入能保持list原有的排序。如果提供 iteratee 函数,iterator将作为list排序的依据,包括你传递的value 。iterator也可以是字符串的属性名用来排序(比如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
findIndex
_.findIndex(array, predicate, [context])
类似于_.indexOf,当predicate通过真检查时,返回第一个索引值;否则返回-1。
_.findIndex([4, 6, 8, 12], isPrime); => -1 // not found _.findIndex([4, 6, 7, 12], isPrime); => 2
findLastIndex
_.findLastIndex(array, predicate, [context])
和_.findIndex类似,但反向迭代数组,当predicate通过真检查时,最接近末端的索引值将被返回。
var users = [{'id': 1, 'name': 'Bob', 'last': 'Brown'}, {'id': 2, 'name': 'Ted', 'last': 'White'}, {'id': 3, 'name': 'Frank', 'last': 'James'}, {'id': 4, 'name': 'Ted', 'last': 'Jones'}]; _.findLastIndex(users, { name: 'Ted' }); => 3
range
_.range([start], stop, [step])
一个用来创建整数灵活编号的列表的函数,便于each 和 map循环。如果省略start则默认为 0;step 默认为 1.返回一个从start 到stop的整数的列表,用step来增加 (或减少)独占。值得注意的是,如果stop值在start前面(也就是stop值小于start值),那么值域会被认为是零长度,而不是负增长。-如果你要一个负数的值域 ,请使用负数step.
_.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); => []