Array

first

_.first(array, [n]) Alias: head, take

返回数组的第一个元素。传递n将返回数组的前n个元素。

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

initial

_.initial(array, [n])

返回除数组的最后一项外的所有内容。对参数对象特别有用。传递n以排除结果中的最后n个元素。

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

last

_.last(array, [n])

返回数组的最后一个元素。传递n将返回数组的最后n个元素。

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

rest

_.rest(array, [index]) Alias: tail, drop

返回数组中其余的元素。传递索引以从该索引向前返回数组的值。

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

紧凑

_.compact(array)

返回删除所有falsy值的数组副本。在JavaScript中，false，null，0，“”，undefined和NaN都是虚假的。

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

compact

_.flatten(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)

返回已删除值的所有实例的数组副本。

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

union

_.union(*arrays)

计算传入数组的联合：唯一项的列表，按顺序存在于一个或多个数组中。

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

intersection

_.intersection(*arrays)

计算所有数组相交值的列表。结果中的每个值都存在于每个数组中。

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

区别

_.difference(array, *others)

类似于无，但返回从值阵列中不存在于其他阵列。

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

uniq

_.uniq(array, [isSorted], [iteratee]) Alias: unique

生成数组的非重复版本，使用===测试对象相等性。特别是只保留每个值的第一次出现。如果您事先知道数组已排序，则传递true以执行isSorted将运行更快的算法。如果你想基于转换来计算唯一的项目，传递一个迭代函数。

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

zip

_.zip(*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 给定一个数组数组，返回一系列新数组，其中第一个包含输入数组中的所有第一个元素，第二个包含所有第二个元素，依此类推。

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

object

_.object(list, [values])

将数组转换为对象。传递关键字，值对的单个列表或关键字列表以及值列表。如果存在重复键，则最后一个值将胜出。

_.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}

indexOf

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

返回处的索引值可以在中找到阵列，或-1，如果值不存在于在阵列。如果你正在处理一个大数组，并且你知道数组已经排序，那么为isSorted传递true 来使用更快的二进制搜索...或者，传递一个数字作为第三个参数以便查找第一个匹配给定索引后数组中的值。

_.indexOf([1, 2, 3], 2
=> 1

lastIndexOf

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

返回最后一次出现的索引值中阵列，或-1，如果值不存在。传递 fromIndex 以在给定的索引处开始搜索。

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

sortedIndex

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

使用二进制搜索来确定值 应该插入列表中的索引，以便维护列表的排序顺序。如果提供迭代函数，它将用于计算每个值的排序顺序，包括您传递的值。迭代器也可以是要排序的属性的字符串名称（例如，长度）。

_.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 类似，返回谓词真值测试通过的第一个索引; 否则返回-1。

_.findIndex([4, 6, 8, 12], isPrime
=> -1 // not found
_.findIndex([4, 6, 7, 12], isPrime
=> 2

findLastIndex

_.findLastIndex(array, predicate, [context])

像_.findIndex但迭代阵列中反向，返回最接近于末尾的索引谓词真相测试通过。

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])

用于创建灵活编号的整数列表的函数，对每个和地图循环都很方便。开始，如果省略，默认为0 ; 步骤默认为1。返回从开始（包含）到停止（排除）的整数列表，按步长递增（或递减），排他。请注意，在开始之前停止的范围被认为是零长度而不是负值 - 如果您想要负范围，请使用负值步骤。

_.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
=> []