Array

_.chunk(array, size=1)

根据size参数将数组分组，size是每一组的长度。如果数组不能均分，最后一组就会包含剩下的元素

初始值

3.0.0

参数

array （Array）：要处理的数组。
[size=1] （大小）：每个块的长度

返回值

（Array）：返回新的数组块。

示例

_.chunk(['a',?'b',?'c',?'d'],?2);
//?=>?[['a',?'b'],?['c',?'d']]
?
_.chunk(['a',?'b',?'c',?'d'],?3);
//?=>?[['a',?'b',?'c'],?['d']]

_.compact(array)

创建一个数组，其中删除所有falsey值。以下的值——false，null，0，""，undefined，和NaN是 falsey。

初始

0.1.0

参数

array （Array）：要压缩的数组。

返回值

（Array）：返回新的过滤值数组。

示例

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

_.concat(array, values)

创建array与任何其他数组和/或值连接的新数组。

初始

4.0.0

参数

array （Array）：要连接的数组。
[values] （... *）：要连接的值。

返回值

（Array）：返回新的连接数组。

示例

var?array?=?[1];

var?other?=?_.concat(array,?2,?[3],?[[4]]);
?

console.log(other);
//?=>?[1,?2,?3,?[4]]
?

console.log(array);
//?=>?[1]

_.difference(array, values)

array使用SameValueZero相等性比较创建未包含在其他给定数组中的值数组。结果值的顺序和引用由第一个数组确定。

注意：与_.pullAll此不同，此方法返回一个新数组。

初始

0.1.0

参数

array （Array）：要检查的数组。
[values] （... Array）：要排除的值。

返回值

（Array）：返回新的过滤值数组。

示例

_.difference([2,?1],?[2,?3]);
//?=>?[1]

_.differenceBy(array, values, iteratee=_.identity)

这种方法类似于_.difference，不同的是它接受iteratee 并为每个元素调用array并values生成它们进行比较的标准。结果值的顺序和引用由第一个数组确定。迭代器因此调用一个参数：

(value).

注意：与_.pullAllBy此不同，此方法返回一个新数组。

初始

4.0.0

参数

array （Array）：要检查的数组。
[values] （... Array）：要排除的值。
[iteratee=_.identity] （Function）：每个元素调用的迭代器。

返回值

（Array）：返回新的过滤值数组。

示例

_.differenceBy([2.1,?1.2],?[2.3,?3.4],?Math.floor);
//?=>?[1.2]
?
//?The?`_.property`?iteratee?shorthand.
_.differenceBy([{?'x':?2?},?{?'x':?1?}],?[{?'x':?1?}],?'x');
//?=>?[{?'x':?2?}]

_.differenceWith(array, values, comparator)

这种方法与_.difference类似，不同之处在于它接受 comparator被调用来比较的元素array到values。结果值的顺序和引用由第一个数组确定。比较器因此调用两个参数：（arrVal，othVal）。

注意：与_.pullAllWith此不同，此方法返回一个新数组。

初始

4.0.0

参数

array (Array): The array to inspect.
[values] (...Array): The values to exclude.
[comparator] (Function): The comparator invoked per element.

（Array）：返回新的过滤值数组。

示例

var?objects?=?[{?'x':?1,?'y':?2?},?{?'x':?2,?'y':?1?}];
?
_.differenceWith(objects,?[{?'x':?1,?'y':?2?}],?_.isEqual);
//?=>?[{?'x':?2,?'y':?1?}]

_.drop(array, n=1)

创建一个切片数组，去除array前面的n个元素。（n默认值为1）

初始

0.5.0

参数

array （Array）：要查询的数组。
[n=1] （数字）：要删除的元素数量。

（数组）：返回部分array。

示例

_.drop([1,?2,?3]);
//?=>?[2,?3]
?
_.drop([1,?2,?3],?2);
//?=>?[3]
?
_.drop([1,?2,?3],?5);
//?=>?[]
?
_.drop([1,?2,?3],?0);
//?=>?[1,?2,?3]

_.dropRight(array, n=1)

创建一个切片数组，去除array后面的n个元素。（n默认值为1）

初始

3.0.0

参数

array （Array）：要查询的数组。
[n=1] （数字）：要删除的元素数量。

（数组）：返回一部分array。

示例

_.dropRight([1,?2,?3]);
//?=>?[1,?2]
?
_.dropRight([1,?2,?3],?2);
//?=>?[1]
?
_.dropRight([1,?2,?3],?5);
//?=>?[]
?
_.dropRight([1,?2,?3],?0);
//?=>?[1,?2,?3]

_.dropRightWhile(array, predicate=_.identity)

创建一个array从结尾删除的排除元素的片段。元素被丢弃，直到predicate返回falsey。谓词用三个参数调用：（value，index，array）。

初始

3.0.0

参数

array （Array）：要查询的数组。
[predicate=_.identity] （Function）：每次迭代调用的函数。

（数组）：返回一部分array。

示例

var?users?=?[
??{?'user':?'barney',??'active':?true?},

??{?'user':?'fred',????'active':?false?},

??{?'user':?'pebbles',?'active':?false?}
];
?
_.dropRightWhile(users,?function(o)?{?return?!o.active;?});
//?=>?objects?for?['barney']
?
//?The?`_.matches`?iteratee?shorthand.
_.dropRightWhile(users,?{?'user':?'pebbles',?'active':?false?});
//?=>?objects?for?['barney',?'fred']
?
//?The?`_.matchesProperty`?iteratee?shorthand.
_.dropRightWhile(users,?['active',?false]);
//?=>?objects?for?['barney']
?
//?The?`_.property`?iteratee?shorthand.
_.dropRightWhile(users,?'active');
//?=>?objects?for?['barney',?'fred',?'pebbles']

_.dropWhile(array, predicate=_.identity)

创建从初始删除的排除元素的一部分array。元素被丢弃，直到 predicate返回falsey。谓词用三个参数调用：（value，index，array）。

初始

3.0.0

参数

array （Array）：要查询的数组。
[predicate=_.identity] （Function）：每次迭代调用的函数。

（数组）：返回部分array。

示例

var?users?=?[
??{?'user':?'barney',??'active':?false?},

??{?'user':?'fred',????'active':?false?},

??{?'user':?'pebbles',?'active':?true?}
];
?
_.dropWhile(users,?function(o)?{?return?!o.active;?});
//?=>?objects?for?['pebbles']
?
//?The?`_.matches`?iteratee?shorthand.
_.dropWhile(users,?{?'user':?'barney',?'active':?false?});
//?=>?objects?for?['fred',?'pebbles']
?
//?The?`_.matchesProperty`?iteratee?shorthand.
_.dropWhile(users,?['active',?false]);
//?=>?objects?for?['pebbles']
?
//?The?`_.property`?iteratee?shorthand.
_.dropWhile(users,?'active');
//?=>?objects?for?['barney',?'fred',?'pebbles']

_.fill(array, value, start=0, end=array.length)

填充的元素array与value来自start为止，但不包括end。

注意： 此方法发生变化array。

初始

3.2.0

参数

array （Array）：要填充的数组。
value （*）：填写的值array。
[start=0] （ number ）：开始位置。
[end=array.length] （ number ）：结束位置。

（Array）：返回array。

示例

var?array?=?[1,?2,?3];
?
_.fill(array,?'a');

console.log(array);
//?=>?['a',?'a',?'a']
?
_.fill(Array(3),?2);
//?=>?[2,?2,?2]
?
_.fill([4,?6,?8,?10],?'*',?1,?3);
//?=>?[4,?'*',?'*',?10]

_.findIndex(array, predicate=_.identity, fromIndex=0)

这个方法就像_.find，不同的是它返回第一个元素的索引，predicate返回truthy而不是元素本身。

初始

1.1.0

参数

array （Array）：要检查的数组。
[predicate=_.identity] （Function）：每次迭代调用的函数。
[fromIndex=0] （number）：从中搜索的索引。

（number）：返回找到的元素的索引，else -1。

示例

var?users?=?[
??{?'user':?'barney',??'active':?false?},

??{?'user':?'fred',????'active':?false?},

??{?'user':?'pebbles',?'active':?true?}
];
?
_.findIndex(users,?function(o)?{?return?o.user?==?'barney';?});
//?=>?0
?
//?The?`_.matches`?iteratee?shorthand.
_.findIndex(users,?{?'user':?'fred',?'active':?false?});
//?=>?1
?
//?The?`_.matchesProperty`?iteratee?shorthand.
_.findIndex(users,?['active',?false]);
//?=>?0
?
//?The?`_.property`?iteratee?shorthand.
_.findIndex(users,?'active');
//?=>?2

_.findLastIndex(array, predicate=_.identity, fromIndex=array.length-1)

这个方法就像_.findIndex，不同的是它遍历collection 从右到左的元素。

初始

2.0.0

参数

array （Array）：要检查的数组。
[predicate=_.identity] （Function）：每次迭代调用的函数。
[fromIndex=array.length-1] （number）：从中搜索的索引。

（number）：返回找到的元素的索引，否则返回-1。

示例

var?users?=?[
??{?'user':?'barney',??'active':?true?},

??{?'user':?'fred',????'active':?false?},

??{?'user':?'pebbles',?'active':?false?}
];
?
_.findLastIndex(users,?function(o)?{?return?o.user?==?'pebbles';?});
//?=>?2
?
//?The?`_.matches`?iteratee?shorthand.
_.findLastIndex(users,?{?'user':?'barney',?'active':?true?});
//?=>?0
?
//?The?`_.matchesProperty`?iteratee?shorthand.
_.findLastIndex(users,?['active',?false]);
//?=>?2
?
//?The?`_.property`?iteratee?shorthand.
_.findLastIndex(users,?'active');
//?=>?0

_.flatten(array)

以单一的深度统一array

初始

0.1.0

参数

array （数组）：要平化的数组。

（ Array ）：返回新的展平数组。

示例

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

_.flattenDeep(array)

递归地平化array。

初始

3.0.0

参数

array （Array）：要平化的数组。

（Array）：返回新的展平数组。

示例

_.flattenDeep([1,?[2,?[3,?[4]],?5]]);
//?=>?[1,?2,?3,?4,?5]

_.flattenDepth(array, depth=1)

递归平化array高达depth倍。

初始

4.4.0

参数

array （Array）：要平化的数组。
[depth=1] （number）：最大递归深度。

(Array): 返回新的平化数组

示例

var?array?=?[1,?[2,?[3,?[4]],?5]];
?
_.flattenDepth(array,?1);
//?=>?[1,?2,?[3,?[4]],?5]
?
_.flattenDepth(array,?2);
//?=>?[1,?2,?3,?[4],?5]

_.fromPairs(pairs)

相反的_.toPairs; 此方法返回由键值组成的对象 pairs。

初始

4.0.0

参数

pairs (Array): 值键对

（Object）：返回新的对象。

示例

_.fromPairs([['a',?1],?['b',?2]]);
//?=>?{?'a':?1,?'b':?2?}

_.head(array)

获取array的第一个元素。

初始

0.1.0

别名

_.first

参数

array （Array）：要查询的数组。

（*）：返回array的第一个元素。

示例

_.head([1,?2,?3]);
//?=>?1
?
_.head([]);
//?=>?undefined

_.indexOf(array, value, fromIndex=0)

获取在其中第一次出现的索引，与value中被发现array使用SameValueZero的相等比较。如果fromIndex为负值，则将其用作从结尾开始的偏移量array。

初始

0.1.0

参数

array （Array）：要检查的数组。
value （*）：要搜索的值。
[fromIndex=0] （number）：从中搜索的索引。

（number）：返回匹配值的索引，否则返回-1。

示例

_.indexOf([1,?2,?1,?2],?2);
//?=>?1
?
//?Search?from?the?`fromIndex`.
_.indexOf([1,?2,?1,?2],?2,?2);
//?=>?3

_.initial(array)

获得array中除了最后一个元素之外的所有元素

初始

0.1.0

参数

array （Array）：要查询的数组。

（Array）：返回部分array。

示例

_.initial([1,?2,?3]);
//?=>?[1,?2]

_.intersection(arrays)

创建一个包含在所有给定数组中的唯一值数组，SameValueZero用于相等性比较。结果值的顺序和引用由第一个数组确定。

初始

0.1.0

参数

[arrays] （... Array）：要检查的数组。

（Array）：返回相交值的新数组。

示例

_.intersection([2,?1],?[2,?3]);
//?=>?[2]

_.intersectionBy(arrays, iteratee=_.identity)

这种方法类似于_.intersection，不同的是它接受 iteratee为每个元素的每个元素调用arrays以生成它们进行比较的标准。结果值的顺序和引用由第一个数组确定。迭代器因此调用一个参数：

(value).

初始

4.0.0

参数

[arrays] （... Array）：要检查的数组。
[iteratee=_.identity] （Function）：每个元素调用的迭代器。

（Array）：返回相交值的新数组。

示例

_.intersectionBy([2.1,?1.2],?[2.3,?3.4],?Math.floor);
//?=>?[2.1]
?
//?The?`_.property`?iteratee?shorthand.
_.intersectionBy([{?'x':?1?}],?[{?'x':?2?},?{?'x':?1?}],?'x');
//?=>?[{?'x':?1?}]

_.intersectionWith(arrays, comparator)

这个方法类似于_.intersection不同的是它接受comparator哪个被调用来比较元素arrays。结果值的顺序和引用由第一个数组确定。比较器调用两个参数：（arrVal，othVal）。

初始

4.0.0

参数

[arrays] （... Array）：要检查的数组。
[comparator] （Function）：每个元素调用比较器。

（Array）：返回相交值的新数组。

示例

var?objects?=?[{?'x':?1,?'y':?2?},?{?'x':?2,?'y':?1?}];

var?others?=?[{?'x':?1,?'y':?1?},?{?'x':?1,?'y':?2?}];
?
_.intersectionWith(objects,?others,?_.isEqual);
//?=>?[{?'x':?1,?'y':?2?}]

_.join(array, separator=',')

将array中所有元素转换为由separator分隔的字符串

初始

4.0.0

参数

array （Array）：要转换的数组。
[separator=','] （string）：元素分隔符。

（string）：返回连接的字符串。

示例

_.join(['a',?'b',?'c'],?'~');
//?=>?'a~b~c'

_.last(array)

获取array最后一个元素。

初始

0.1.0

参数

array （Array）：要查询的数组。

（*）：返回array的最后一个元素。

示例

_.last([1,?2,?3]);
//?=>?3

_.lastIndexOf(array, value, fromIndex=array.length-1)

这个方法就像_.indexOf，不同的是它遍历array 从右到左的元素。

初始

0.1.0

参数

array （Array）：要检查的数组。
value （*）：要搜索的值。
[fromIndex=array.length-1] （number）：从中搜索的索引。

（number）：返回匹配值的索引，否则返回-1。

示例

_.lastIndexOf([1,?2,?1,?2],?2);
//?=>?3
?
//?Search?from?the?`fromIndex`.
_.lastIndexOf([1,?2,?1,?2],?2,?2);
//?=>?1

_.nth(array, n=0)

获取索引n处的元素array。如果n是负数，则返回从结尾开始的第n个元素。

初始

4.11.0

参数

array （Array）：要查询的数组。
[n=0] （number）：要返回的元素的索引。

（*）：返回array的第n个元素。

示例

var?array?=?['a',?'b',?'c',?'d'];
?
_.nth(array,?1);
//?=>?'b'
?
_.nth(array,?-2);
//?=>?'c';

_.pull(array, values)

将删除所有给定值array用SameValueZero平等地比较。

注意：与_.without不同，此方法会发生使array变化，用_.remove谓词从数组中移除元素。

初始

2.0.0

参数

array （Array）：要修改的数组。
[values] （... *）：要删除的值。

（Array）：返回array。

示例

var?array?=?['a',?'b',?'c',?'a',?'b',?'c'];
?
_.pull(array,?'a',?'c');

console.log(array);
//?=>?['b',?'b']

_.pullAll(array, values)

这个方法就像_.pull，不同的是它接受一个要移除的值的数组。

注意：与_.difference此不同，此方法会使array发生变化。

初始

4.0.0

参数

array （Array）：要修改的数组。
values （Array）：要删除的值。

（Array）：返回array。

示例

var?array?=?['a',?'b',?'c',?'a',?'b',?'c'];
?
_.pullAll(array,?['a',?'c']);

console.log(array);
//?=>?['b',?'b']

_.pullAllBy(array, values, iteratee=_.identity)

这种方法类似于_.pullAll，不同的是它接受iteratee为每个元素调用array并values生成它们进行比较的标准。迭代器调用一个参数：（value）。

注意：与_.differenceBy此不同，此方法会使array发生变化。

初始

4.0.0

参数

array （Array）：要修改的数组。
values （Array）：要删除的值。
[iteratee=_.identity] （Function）：每个元素调用的迭代器。

（Array）：返回array。

例

var?array?=?[{?'x':?1?},?{?'x':?2?},?{?'x':?3?},?{?'x':?1?}];
?
_.pullAllBy(array,?[{?'x':?1?},?{?'x':?3?}],?'x');

console.log(array);
//?=>?[{?'x':?2?}]

_.pullAllWith(array, values, comparator)

这种方法如_.pullAll，不同之处在于它接受comparator 被调用来比较的元素array到values。比较器被调用两个参数：（arrVal，othVal）。

注意：与_.differenceWith不同，此方法会使array发生变化。

初始

4.6.0

参数

array （Array）：要修改的数组。
values （Array）：要删除的值。
[comparator] （Function）：每个元素调用比较器。

（Array）：返回array。

示例

var?array?=?[{?'x':?1,?'y':?2?},?{?'x':?3,?'y':?4?},?{?'x':?5,?'y':?6?}];
?
_.pullAllWith(array,?[{?'x':?3,?'y':?4?}],?_.isEqual);

console.log(array);
//?=>?[{?'x':?1,?'y':?2?},?{?'x':?5,?'y':?6?}]

_.pullAt(array, indexes)

从array相应的元素中移除元素indexes并返回一个已移除元素的数组。

注意：与_.at此不同，此方法会使array发生变化。

初始

3.0.0

参数

array （Array）：要修改的数组。
[indexes] （...（number | number []））：要移除的元素的索引。

（Array）：返回已移除元素的新数组。

例

var?array?=?['a',?'b',?'c',?'d'];

var?pulled?=?_.pullAt(array,?[1,?3]);
?

console.log(array);
//?=>?['a',?'c']
?

console.log(pulled);
//?=>?['b',?'d']

_.remove(array, predicate=_.identity)

从array移除所有元素，predicate返回truthy并返回删除的元素的阵列。谓词用三个参数调用：（value，index，array）。

注意： 与_.filter此不同，此方法会使之发生变化。用于_.pull通过值从数组中提取元素。

初始

2.0.0

参数

array （Array）：要修改的数组。
[predicate=_.identity] （Function）：每次迭代调用的函数。

（Array）：返回已移除元素的新数组。

例

var?array?=?[1,?2,?3,?4];

var?evens?=?_.remove(array,?function(n)?{
??return?n?%?2?==?0;
});
?

console.log(array);
//?=>?[1,?3]
?

console.log(evens);
//?=>?[2,?4]

_.reverse(array)

反转array使第一个元素成为最后一个，第二个元素成为倒数第二个元素，依此类推。

注意：此方法变异于array并基于Array#reverse。

初始

4.0.0

参数

array （Array）：要修改的数组。

（数组）：返回array。

例

var?array?=?[1,?2,?3];
?
_.reverse(array);
//?=>?[3,?2,?1]
?

console.log(array);
//?=>?[3,?2,?1]

_.slice(array, start=0, end=array.length)

创建一个array从start一直到但不包括自身的部分end。

注意：此方法用于Array#slice 以确保返回密集数组。

初始

3.0.0

参数

array （Array）：要切片的数组。
[start=0] （number）：开始位置。
[end=array.length] （number）：结束位置。

（Array）：返回部分array。

_.sortedIndex(array, value)

使用二进制搜索来确定value应该插入的最低索引即array的最低索引以便维护其排序顺序。

初始

0.1.0

参数

array （Array）：要检查的排序数组。
value （*）：要评估的值。

（number）：返回value应插入的索引array。

例

_.sortedIndex([30,?50],?40);
//?=>?1

_.sortedIndexBy(array, value, iteratee=_.identity)

这个方法就像_.sortedIndex,不同的是它接受 iteratee调用的方法value和每个元素array来计算它们的排序顺序。迭代器被调用一个参数：（value）。

初始

4.0.0

参数

array （Array）：要检查的排序数组。
value （*）：要评估的值。
[iteratee=_.identity] （Function）：每个元素调用的迭代器。

（number）：返回value应插入的索引array。

例

var?objects?=?[{?'x':?4?},?{?'x':?5?}];
?
_.sortedIndexBy(objects,?{?'x':?4?},?function(o)?{?return?o.x;?});
//?=>?0
?
//?The?`_.property`?iteratee?shorthand.
_.sortedIndexBy(objects,?{?'x':?4?},?'x');
//?=>?0

_.sortedIndexOf(array, value)

这种方法就像_.indexOf，不同的是它在排序后执行二分搜索 array。

初始

4.0.0

参数

array （Array）：要检查的数组。
value （*）：要搜索的值。

（number）：返回匹配值的索引，否则返回-1。

例

_.sortedIndexOf([4,?5,?5,?5,?6],?5);
//?=>?1

_.sortedLastIndex(array, value)

这个方法就像_.sortedIndex，不同的是它返回value应该插入array的最高索引，以便维护它的排序顺序。

初始

3.0.0

参数

array （Array）：要检查的排序数组。
value （*）：要评估的值。

（number）：返回value应插入array的索引。

例

_.sortedLastIndex([4,?5,?5,?5,?6],?5);
//?=>?4

_.sortedLastIndexBy(array, value, iteratee=_.identity)

这个方法就像_.sortedLastIndex，不同的是它接受iteratee 调用的方法value和每个元素array来计算它们的排序顺序。迭代器被调用一个参数：（value）。

初始

4.0.0

参数

array （Array）：要检查的排序数组。
value （*）：要评估的值。
[iteratee=_.identity] （Function）：每个元素调用的迭代器。

（number）：返回value应插入的索引array。

例

var?objects?=?[{?'x':?4?},?{?'x':?5?}];
?
_.sortedLastIndexBy(objects,?{?'x':?4?},?function(o)?{?return?o.x;?});
//?=>?1
?
//?The?`_.property`?iteratee?shorthand.
_.sortedLastIndexBy(objects,?{?'x':?4?},?'x');
//?=>?1

_.sortedLastIndexOf(array, value)

这种方法就像_.lastIndexOf，不同的是它在排序后执行二分搜索array。

初始

4.0.0

参数

array （Array）：要检查的数组。
value （*）：要搜索的值。

（number）：返回匹配值的索引，否则返回-1。

例

_.sortedLastIndexOf([4,?5,?5,?5,?6],?5);
//?=>?3

_.sortedUniq(array)

这种方法就像_.uniq，不同的是它为排序数组设计和优化的。

初始

4.0.0

参数

array （Array）：要检查的数组。

（Array）：返回新的重复空闲数组。

例

_.sortedUniq([1,?1,?2]);
//?=>?[1,?2]

_.sortedUniqBy(array, iteratee)

这种方法就像_.uniqBy，不同的是它是为排序数组设计和优化的。

初始

4.0.0

参数

array （Array）：要检查的数组。
[iteratee] （Function）：每个元素调用的迭代器。

（Array）：返回新的重复空闲数组。

例

_.sortedUniqBy([1.1,?1.2,?2.3,?2.4],?Math.floor);
//?=>?[1.1,?2.3]

_.tail(array)

除了第一个元素之外，都获得array的所有元素。

初始

4.0.0

参数

array （Array）：要查询的数组。

（Array）：返回部分array。

例

_.tail([1,?2,?3]);
//?=>?[2,?3]

_.take(array, n=1)

使用n从头开始的元素创建一部分array。

初始

0.1.0

参数

array （Array）：要查询的数组。
[n=1] （number）：要采取的元素数量。

（Array）：返回部分array。

例

_.take([1,?2,?3]);
//?=>?[1]
?
_.take([1,?2,?3],?2);
//?=>?[1,?2]
?
_.take([1,?2,?3],?5);
//?=>?[1,?2,?3]
?
_.take([1,?2,?3],?0);
//?=>?[]

_.takeRight(array, n=1)

创建一个从最终获得的n元素的一部分array

初始

3.0.0

参数

array （Array）：要查询的数组。
[n=1] （number）：要采取的元素数量。

（number）：返回部分array。

例

_.takeRight([1,?2,?3]);
//?=>?[3]
?
_.takeRight([1,?2,?3],?2);
//?=>?[2,?3]
?
_.takeRight([1,?2,?3],?5);
//?=>?[1,?2,?3]
?
_.takeRight([1,?2,?3],?0);
//?=>?[]

_.takeRightWhile(array, predicate=_.identity)

创建一个从最后采取的元素的一部分array。提取元素，直到 predicate返回falsey为止。谓词用三个参数调用：（value，index，array）。

初始

3.0.0

参数

array （Array）：要查询的数组。
[predicate=_.identity] （Function）：每次迭代调用的函数。

（Array）：返回部分array。

例

var?users?=?[
??{?'user':?'barney',??'active':?true?},

??{?'user':?'fred',????'active':?false?},

??{?'user':?'pebbles',?'active':?false?}
];
?
_.takeRightWhile(users,?function(o)?{?return?!o.active;?});
//?=>?objects?for?['fred',?'pebbles']
?
//?The?`_.matches`?iteratee?shorthand.
_.takeRightWhile(users,?{?'user':?'pebbles',?'active':?false?});
//?=>?objects?for?['pebbles']
?
//?The?`_.matchesProperty`?iteratee?shorthand.
_.takeRightWhile(users,?['active',?false]);
//?=>?objects?for?['fred',?'pebbles']
?
//?The?`_.property`?iteratee?shorthand.
_.takeRightWhile(users,?'active');
//?=>?[]

_.takeWhile(array, predicate=_.identity)

使用从头开始的元素创建一部分array。提取元素直到predicate 返回false为止。谓词用三个参数调用：（value，index，array）。

初始

3.0.0

参数

array （Array）：要查询的数组。
[predicate=_.identity] （Function）：每次迭代调用的函数。

（Array）：返回部分array。

例

var?users?=?[
??{?'user':?'barney',??'active':?false?},

??{?'user':?'fred',????'active':?false?},

??{?'user':?'pebbles',?'active':?true?}
];
?
_.takeWhile(users,?function(o)?{?return?!o.active;?});
//?=>?objects?for?['barney',?'fred']
?
//?The?`_.matches`?iteratee?shorthand.
_.takeWhile(users,?{?'user':?'barney',?'active':?false?});
//?=>?objects?for?['barney']
?
//?The?`_.matchesProperty`?iteratee?shorthand.
_.takeWhile(users,?['active',?false]);
//?=>?objects?for?['barney',?'fred']
?
//?The?`_.property`?iteratee?shorthand.
_.takeWhile(users,?'active');
//?=>?[]

_.union(arrays)

从所有给定的数组中依次创建一个唯一值数组，SameValueZero用于相等性比较。

初始

0.1.0

参数

[arrays] （... Array）：要检查的数组。

（Array）：返回组合值的新数组。

例

_.union([2],?[1,?2]);
//?=>?[2,?1]

_.unionBy(arrays, iteratee=_.identity)

这种方法类似，_.union，不同之处在于它接受iteratee为每个元素调用每个元素arrays以生成唯一性计算标准。结果值从第一个出现值的数组中选择。迭代器被调用一个参数：

(value).

初始

4.0.0

参数

[arrays] （... Array）：要检查的数组。
[iteratee=_.identity] （Function）：每个元素调用的迭代器。

（Array）：返回组合值的新数组。

例

_.unionBy([2.1],?[1.2,?2.3],?Math.floor);
//?=>?[2.1,?1.2]
?
//?The?`_.property`?iteratee?shorthand.
_.unionBy([{?'x':?1?}],?[{?'x':?2?},?{?'x':?1?}],?'x');
//?=>?[{?'x':?1?},?{?'x':?2?}]

_.unionWith(arrays, comparator)

这个方法类似于_.union，不同的是它接受comparator哪个被调用来比较元素arrays。结果值从第一个出现值的数组中选择。比较器被调用两个参数：（arrVal，othVal）。

初始

4.0.0

参数

[arrays] （... Array）：要检查的数组。
[comparator] （Function）：每个元素调用比较器。

（Array）：返回组合值的新数组。

例

var?objects?=?[{?'x':?1,?'y':?2?},?{?'x':?2,?'y':?1?}];

var?others?=?[{?'x':?1,?'y':?1?},?{?'x':?1,?'y':?2?}];
?
_.unionWith(objects,?others,?_.isEqual);
//?=>?[{?'x':?1,?'y':?2?},?{?'x':?2,?'y':?1?},?{?'x':?1,?'y':?1?}]

_.uniq(array)

创建数组的无重复版本，SameValueZero用于相等比较，其中只保留每个元素的第一个匹配项。结果值的顺序由它们在数组中出现的顺序决定。

初始

0.1.0

参数

array （Array）：要检查的数组。

（Array）：返回新的重复空闲数组。

例

_.uniq([2,?1,?2]);
//?=>?[2,?1]

_.uniqBy(array, iteratee=_.identity)

此方法类似于_.uniq，不同的是它接受iteratee为每个元素调用array以生成唯一性计算标准的方法。结果值的顺序由它们在数组中出现的顺序决定。迭代器被调用一个参数：

(value).

初始

4.0.0

参数

array （Array）：要检查的数组。
[iteratee=_.identity] （Function）：每个元素调用的迭代器。

（Array）：返回新的重复空闲数组。

例

_.uniqBy([2.1,?1.2,?2.3],?Math.floor);
//?=>?[2.1,?1.2]
?
//?The?`_.property`?iteratee?shorthand.
_.uniqBy([{?'x':?1?},?{?'x':?2?},?{?'x':?1?}],?'x');
//?=>?[{?'x':?1?},?{?'x':?2?}]

_.uniqWith(array, comparator)

这个方法类似于_.uniq，不同的是它接受comparator哪个被调用来比较元素array。结果值的顺序由它们在数组中出现的顺序决定。使用两个参数调用比较器：（arrVal，othVal）。

初始

4.0.0

参数

array （Array）：要检查的数组。
[comparator] （Function）：每个元素调用比较器。

（Array）：返回新的重复空闲数组。

例

var?objects?=?[{?'x':?1,?'y':?2?},?{?'x':?2,?'y':?1?},?{?'x':?1,?'y':?2?}];
?
_.uniqWith(objects,?_.isEqual);
//?=>?[{?'x':?1,?'y':?2?},?{?'x':?2,?'y':?1?}]

_.unzip(array)

这种方法就像_.zip，不同的是它接受一个分组元素数组，并创建一个数组，将这些元素重新组合到它们的pre-zip配置中。

初始

1.2.0

参数

array （Array）：要处理的分组元素的数组。

（Array）：返回重新组合元素的新数组。

例

var?zipped?=?_.zip(['a',?'b'],?[1,?2],?[true,?false]);
//?=>?[['a',?1,?true],?['b',?2,?false]]
?
_.unzip(zipped);
//?=>?[['a',?'b'],?[1,?2],?[true,?false]]

_.unzipWith(array, iteratee=_.identity)

这种方法就像_.unzip，不同的是它接受iteratee指定应该如何组合重组值。迭代器用每个组的元素调用： （... group）。

初始

3.8.0

参数

array （Array）：要处理的分组元素的数组。
[iteratee=_.identity] （function）：组合重组值的功能。

（Array）：返回重新组合元素的新数组。

例

var?zipped?=?_.zip([1,?2],?[10,?20],?[100,?200]);
//?=>?[[1,?10,?100],?[2,?20,?200]]
?
_.unzipWith(zipped,?_.add);
//?=>?[3,?30,?300]

_.without(array, values)

使用SameValueZero相等比较创建排除所有给定值的数组。

注意：与_.pull不同，此方法返回一个新数组。

初始

0.1.0

参数

array （Array）：要检查的数组。
[values] （... *）：要排除的值。

（Array）：返回新的过滤值数组。

例

_.without([2,?1,?2,?3],?1,?2);
//?=>?[3]

_.xor（阵列）

创建一个唯一值的数组，它是给定数组的对称差异。结果值的顺序由它们在数组中出现的顺序决定。

初始

2.4.0

参数

[arrays] （... Array）：要检查的数组。

（Array）：返回新的过滤值数组。

例

_.xor([2,?1],?[2,?3]);
//?=>?[1,?3]

_.xorBy(arrays, iteratee=_.identity)

这种方法就像_.xor，不同的是它接受iteratee为每个元素调用每个元素arrays来生成他们所比较的标准。结果值的顺序由它们在数组中出现的顺序决定。迭代器被调用一个参数：（value）。

初始

4.0.0

参数

[arrays] （... Array）：要检查的数组。
[iteratee=_.identity] （Function）：每个元素调用的迭代器。

（Array）：返回新的过滤值数组。

例

_.xorBy([2.1,?1.2],?[2.3,?3.4],?Math.floor);
//?=>?[1.2,?3.4]
?
//?The?`_.property`?iteratee?shorthand.
_.xorBy([{?'x':?1?}],?[{?'x':?2?},?{?'x':?1?}],?'x');
//?=>?[{?'x':?2?}]

_.xorWith(arrays, comparator)

这个方法类似于_.xor，不同的是它接受comparator哪个被调用来比较元素arrays。结果值的顺序由它们在数组中出现的顺序决定。比较器被调用两个参数：（arrVal，othVal）。

初始

4.0.0

参数

[arrays] （... Array）：要检查的数组。
[comparator] （Function）：每个元素调用比较器。

（Array）：返回新的过滤值数组。

例

var?objects?=?[{?'x':?1,?'y':?2?},?{?'x':?2,?'y':?1?}];

var?others?=?[{?'x':?1,?'y':?1?},?{?'x':?1,?'y':?2?}];
?
_.xorWith(objects,?others,?_.isEqual);
//?=>?[{?'x':?2,?'y':?1?},?{?'x':?1,?'y':?1?}]

_.zip(arrays)

创建一个分组元素数组，其中第一个元素包含给定数组的第一个元素，第二个元素包含给定数组的第二个元素，依此类推。

初始

0.1.0

参数

[arrays] （... Array）：要处理的数组。

（Array）：返回分组元素的新数组。

例

_.zip(['a',?'b'],?[1,?2],?[true,?false]);
//?=>?[['a',?1,?true],?['b',?2,?false]]

_.zipObject([props=[]], [values=[]])

这个方法就像_.fromPairs，它接受两个数组，一个属性标识符和一个相应的值。

初始

0.4.0

参数

[props=[]] （Array）：属性标识符。
[values=[]] （Array）：属性值。

（Object）：返回新的对象。

例

_.zipObject(['a',?'b'],?[1,?2]);
//?=>?{?'a':?1,?'b':?2?}

_.zipObjectDeep([props=[]], [values=[]])

这种方法就像_.zipObject,它支持属性路径。

初始

4.1.0

参数

[props=[]] （Array）：属性标识符。
[values=[]] （Array）：属性值。

（Object）：返回新的对象。

例

_.zipObjectDeep(['a.b[0].c',?'a.b[1].d'],?[1,?2]);
//?=>?{?'a':?{?'b':?[{?'c':?1?},?{?'d':?2?}]?}?}

_.zipWith(arrays, iteratee=_.identity)

这个方法就像_.zip,它接受iteratee指定应该如何组合分组值。迭代器用每个组的元素调用：（... group）。

初始

3.8.0

参数

[arrays] （... Array）：要处理的数组。
[iteratee=_.identity] （Function）：组合分组值的功能。

（Array）：返回分组元素的新数组。

例

_.zipWith([1,?2],?[10,?20],?[100,?200],?function(a,?b,?c)?{
??return?a?+?b?+?c;
});
//?=>?[111,?222]

本文档系腾讯云开发者社区成员共同维护，如有问题请联系 cloudcommunity@tencent.com

最后更新于：2021-03-29