Lodash 中文文档 (v3.10.1) - “Array” 方法
Translated by PeckZeg
Original Docs: Lodash v3.10.1 Docs
更新日志
2015-01-02
感谢 @neuront 对
_.flatten
翻译的建议
“Array” 方法
_.chunk(array, [size=1])
创建一个元素分成长度为 size
的分组的数组。如果 collection
不能被均匀的分割,那么最后一个区块将会包含剩余的元素。
参数
array
(Array) : 待处理的数组[size=1]
(number) : 每个区块的长度
返回
(Array) : 返回包含每个区块的新数组
示例
_.chunk(['a', 'b', 'c', 'd'], 2);
// → [['a', 'b'], ['c', 'd']]
_.chunk(['a', 'b', 'c', 'd'], 3);
// → [['a', 'b', 'c'], ['d']]
_.compact(array)
创建一个移除了所有假值的数组。值 false
, null
, 0
, ""
, undefined
和 NaN
均为假值。
参数
array
(Array) : 待简化的数组
返回
(Array) : 返回过滤值后的新数组
示例
_.compact([0, 1, false, 2, '', 3]);
// → [1, 2, 3]
_.difference(array, [values])
创建一个每个值都不包含在其他的提供的的数组内的值的数组(使用 SameValueZero
进行相等比较)。
参数
array
(Array) : 待检查的数组[values]
(…Array) : 待排除值的数组
返回
(Array) : 返回过滤值后的新数组
示例
_.difference([1, 2, 3], [4, 2]);
// → [1, 3]
_.drop(array, [n=1])
创建一个从起始位置开始删除 n
个元素后的数组分片。
参数
array
(Array) : 待查询的数组[n=1]
(number) : 待删除的元素个数
返回
(Array) : 返回分片后的 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])
创建一个从尾部位置开始删除 n
个元素后的数组分片。
参数
array
(Array) : 待查询的数组[n=1]
(number) : 删除元素的个数
返回
(Array) : 返回分片后的 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], [thisArg])
创建一个从尾部开始舍弃元素 array
的分片。在 predicate
返回假值之前一直舍弃元素。断言将被绑定 thisArg
参数并在执行时传入三个参数:value
, index
, array
。
如果提供的是属性名,那么 predicate
将创建 _.property
风格的回调函数,并返回给定元素的属性的值。
如果值还提供了 thisArg
,那么 predicate
将创建 _.matchesProperty
风格的回调,并在元素含有匹配的属性值的时候返回 true
,否则返回 false
。
如果提供的是对象,那么 predicate
将创建 _.matches
风格的回调函数,并在匹配给定对象的属性的元素时返回 true
,否则返回 false
。
参数
array
(Array) : 待查询的数组[predicate=_.identity]
(Function|Object|string) : 每次迭代将会执行的函数[thisArg]
(*) :predicate
将要绑定的this
返回
(Array) : 返回 array
的分片
示例
_.dropRightWhile([1, 2, 3], function(n) {
return n > 1;
});
// → [1]
var users = [
{ 'user': 'barney', 'active': true },
{ 'user': 'fred', 'active': false },
{ 'user': 'pebbles', 'active': false }
];
// 使用 `_.matches` 回调函数的简称
_.pluck(_.dropRightWhile(users, { 'user': 'pebbles', 'active': false }), 'user');
// → ['barney', 'fred']
// 使用 `_.matchesProperty` 回调函数的简称
_.pluck(_.dropRightWhile(users, 'active', false), 'user');
// → ['barney']
// 使用 `_.property` 回调函数的简称
_.pluck(_.dropRightWhile(users, 'active'), 'user');
// → ['barney', 'fred', 'pebbles']
_.dropWhile(array, [predicate=_.identity], [thisArg])
创建一个从起始位置开始舍弃元素 array
的分片。在 predicate
返回假值之前一直舍弃元素。断言将被绑定 thisArg
参数并在执行时传入三个参数:value
, index
, array
。
如果提供的是属性名,那么 predicate
将创建 _.property
风格的回调函数,并返回给定元素的属性的值。
如果值还提供了 thisArg
,那么 predicate
将创建 _.matchesProperty
风格的回调,并在元素含有匹配的属性值的时候返回 true
,否则返回 false
。
如果提供的是对象,那么 predicate
将创建 _.matches
风格的回调函数,并在匹配给定对象的属性的元素时返回 true
,否则返回 false
。
参数
array
(Array) : 待查询的数组[predicate=_.identity]
(Function|Object|string) : 每次迭代将会执行的函数[thisArg]
(*) :predicate
将要绑定的this
返回
(Array) : 返回 array
的分片
示例
_.dropWhile([1, 2, 3], function(n) {
return n < 3;
});
// → [3]
var users = [
{ 'user': 'barney', 'active': false },
{ 'user': 'fred', 'active': false },
{ 'user': 'pebbles', 'active': true }
];
// 使用 `_.matches` 回调函数的简称
_.pluck(_.dropWhile(users, { 'user': 'barney', 'active': false }), 'user');
// → ['fred', 'pebbles']
// 使用 `_.matchesProperty` 回调函数的简称
_.pluck(_.dropWhile(users, 'active', false), 'user');
// → ['pebbles']
// 使用 `_.property` 回调函数的简称
_.pluck(_.dropWhile(users, 'active'), 'user');
// → ['barney', 'fred', 'pebbles']
_.fill(array, value, [start=0], [end=array.length])
使用 value
填充 array
的元素(从 start
位置开始,但不包括 end
)
注意:该方法将改变数组
参数
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], '*', 1, 2);
// → [4, '*', 8]
_.findIndex(array, [predicate=_.identity], [thisArg])
这个函数类似 _.find
但它返回的是通过 predicate
返回真值的第一个元素的索引值,而不是其元素本身。
如果提供的是属性名,那么 predicate
将创建 _.property
风格的回调函数,并返回给定元素的属性的值。
如果值还提供了 thisArg
,那么 predicate
将创建 _.matchesProperty
风格的回调,并在元素含有匹配的属性值的时候返回 true
,否则返回 false
。
如果提供的是对象,那么 predicate
将创建 _.matches
风格的回调函数,并在匹配给定对象的属性的元素时返回 true
,否则返回 false
。
参数
array
(Array) : 待查找的数组[predicate=_.identity]
(Function|Object|string) : 每次迭代执行的函数[thisArg]
(*) :predicate
绑定的this
返回
(number) : 返回查找到的元素的索引值,否则为 -1
示例
var users = [
{ 'user': 'barney', 'active': false },
{ 'user': 'fred', 'active': false },
{ 'user': 'pebbles', 'active': true }
];
_.findIndex(users, function(chr) {
return chr.user == 'barney';
});
// → 0
// 使用 `_.matches` 回调函数的简称
_.findIndex(users, { 'user': 'fred', 'active': false });
// → 1
// 使用 `_.matchesProperty` 回调函数的简称
_.findIndex(users, 'active', false);
// → 0
// 使用 `_.property` 回调函数的简称
_.findIndex(users, 'active');
// → 2
_.findLastIndex(array, [predicate=_.identity], [thisArg])
这个函数类似 _.findIndex
,但它会从右往左遍历 collection
的元素。
如果提供的是属性名,那么 predicate
将创建 _.property
风格的回调函数,并返回给定元素的属性的值。
如果值还提供了 thisArg
,那么 predicate
将创建 _.matchesProperty
风格的回调,并在元素含有匹配的属性值的时候返回 true
,否则返回 false
。
如果提供的是对象,那么 predicate
将创建 _.matches
风格的回调函数,并在匹配给定对象的属性的元素时返回 true
,否则返回 false
。
参数
array
(Array) : 待查找的数组[predicate=_.identity]
(Function|Object|string) : 每次迭代执行的函数[thisArg]
(*) :predicate
绑定的this
返回
(number) : 返回查找到的元素的索引值,否则为 -1
示例
var users = [
{ 'user': 'barney', 'active': true },
{ 'user': 'fred', 'active': false },
{ 'user': 'pebbles', 'active': false }
];
_.findLastIndex(users, function(chr) {
return chr.user == 'pebbles';
});
// → 2
// 使用 `_.matches` 回调函数的简称
_.findLastIndex(users, { 'user': 'barney', 'active': true });
// → 0
// 使用 `_.matchesProperty` 回调函数的简称
_.findLastIndex(users, 'active', false);
// → 2
// 使用 `_.property` 回调函数的简称
_.findLastIndex(users, 'active');
// → 0
_.first(array)
获取 array
的第一个元素
别称
_.head
参数
array
(Array) : 待查询的数组
返回
(*) : 返回 array
的第一个元素
示例
_.first([1, 2, 3]);
// → 1
_.first([]);
// → undefined
_.flatten(array, [isDeep])
连接所有数组元素。如果 isDeep
指定为 true
,那么数组元素会递归连接,否则它将只连接一层数组元素。
参数
array
(Array) : 待连接的数组[isDeep]
(boolean) : 指定是否连接深层的数组元素
返回
(Array) : 返回一个连接所有数组元素的新数组
示例
_.flatten([1, [2, 3, [4]]]);
// → [1, 2, 3, [4]]
// 使用 `isDeep`
_.flatten([1, [2, 3, [4]]], true);
// → [1, 2, 3, 4]
_.flattenDeep(array)
递归拍平一个嵌套数组
参数
array
(Array) : 待递归拍平的数组
返回
(Array) : 返回一个被拍平过的数组
示例
_.flattenDeep([1, [2, 3, [4]]]);
// → [1, 2, 3, 4]
_.indexOf(array, value, [fromIndex=0])
获取 value
首次在 array
出现的索引(使用 SameValueZero
进行相等性比较)。如果 fromIndex
为负数,则作为 array
从尾部的位移。如果 array
已整理,且传入 fromIndex
值为 true
,则将使用更高效的二分查找。
参数
array
(Array) : 待查找的数组value
(*) : 待查找的值[fromIndex=0]
(boolean|number) : 开始查找的索引位置或传入true
以代表使用二分查找
返回
(number) : 返回匹配值的索引,否则返回 -1
示例
_.indexOf([1, 2, 1, 2], 2);
// → 1
// 使用 `fromIndex`
_.indexOf([1, 2, 1, 2], 2, 2);
// → 3
// 执行二分查找
_.indexOf([1, 1, 2, 2], 2, true);
// → 2
_.initial(array)
Gets all but the last element of array.
获取 array
中所有元素(除了最后一个元素)
参数
array
(Array) : 待查询的数组
返回
(Array) : 返回 array
的分片
示例
_.initial([1, 2, 3]);
// → [1, 2]
_.intersection([arrays])
获取所有传入数组中都包含的元素(使用 SameValueZero
进行相等性比较)
参数
[arrays]
(…Array) : 待检查的数组
返回
(Array) : 返回一个包含所有传入数组中都包含的元素的新数组
示例
_.intersection([1, 2], [4, 2], [2, 1]);
// → [2]
_.last(array)
Gets the last element of array.
获取 array
的最后一个元素
参数
array
(Array) : 待查询的数组
返回
(*) : 返回 array
的最后一个元素
示例
_.last([1, 2, 3]);
// → 3
_.lastIndexOf(array, value, [fromIndex=array.length-1])
这个函数类似 _.indexOf
,但它从右到左遍历 array
的所有元素
参数
array
(Array) : 待查找的数组value
(*) : 待查找的值[fromIndex=0]
(boolean|number) : 开始查找的索引位置或传入true
以代表使用二分查找
参数
(number) : 返回匹配值的索引,否则返回 -1
示例
_.lastIndexOf([1, 2, 1, 2], 2);
// → 3
// using `fromIndex`
_.lastIndexOf([1, 2, 1, 2], 2, 2);
// → 1
// performing a binary search
_.lastIndexOf([1, 1, 2, 2], 2, true);
// → 3
_.pull(array, [values])
从 array
中移除所有指定的值(使用 SameValueZero
进行相等性比较)。
注意:和 _.without
不同,这个方法将会改变数组
参数
array
(Array) : 待修改的数组[values]
(…*) : 待移除的值
返回
(Array) : 返回 array
示例
var array = [1, 2, 3, 1, 2, 3];
_.pull(array, 2, 3);
console.log(array);
// → [1, 1]
_.pullAt(array, [indexes])
从 array
移除给定索引的元素,并返回一个移除元素的数组。索引可以被指定为一个数组或多个参数。
注意:与 _.at
不同,该方法会修改 array
。
参数
array
(Array) : 待修改的数组[indexes]
(…(number|number[]) : 待移除元素的索引,可以指定为多个参数或者索引数组
返回
(Array) : 返回含有已移除元素的数组
示例
var array = [5, 10, 15, 20];
var evens = _.pullAt(array, 1, 3);
console.log(array);
// → [5, 15]
console.log(evens);
// → [10, 20]
_.remove(array, [predicate=_.identity], [thisArg])
移除所有在 array
中并通过 predicate
的元素,并返回所有移除元素的数组。断言函数绑定 thisArg
并传入三个参数:value
, index
, array
。
如果提供的是属性名,那么 predicate
将创建 _.property
风格的回调函数,并返回给定元素的属性的值。
如果值还提供了 thisArg
,那么 predicate
将创建 _.matchesProperty
风格的回调,并在元素含有匹配的属性值的时候返回 true
,否则返回 false
。
如果提供的是对象,那么 predicate
将创建 _.matches
风格的回调函数,并在匹配给定对象的属性的元素时返回 true
,否则返回 false
。
注意:和 _.filter
不同,该方法将改变数组
参数
array
(Array) : 待修改的数组[predicate=_.identity]
(Function|Object|string) : 每次迭代执行的函数[thisArg]
(*) :predicate
绑定的this
返回
(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]
_.rest(array)
Gets all but the first element of array.
获取 array
的除第一个外的所有元素。
别名
_.tail
参数
返回
(Array) : 待查询的数组
返回
(Array) : 返回 array
的分片
示例
_.rest([1, 2, 3]);
// → [2, 3]
_.slice(array, [start=0], [end=array.length])
创建一个从 start
位置开始,但不包含 end
位置元素的 array
的分片
注意:该方法通常用来替代 IE < 9 以下的 Array#slice
函数,以确保密集数组的返回。
参数
array
(Array) : 待分片的数组[start=0]
(number) : 起始位置[end=array.length]
(number) : 结束位置
返回
(Array) : 返回 array
的分片
_.sortedIndex(array, value, [iteratee=_.identity], [thisArg])
使用二分查找来确定 value
在 array
中应该插入的最小的索引位置(为了保持 array
的排序顺序)。如果为了计算其排序值而将 value
和每次遍历的元素传入迭代函数,那么迭代器将绑定 thisArg
并在执行时传入一个参数 value
。
如果提供的是属性名,那么 predicate
将创建 _.property
风格的回调函数,并返回给定元素的属性的值。
如果值还提供了 thisArg
,那么 predicate
将创建 _.matchesProperty
风格的回调,并在元素含有匹配的属性值的时候返回 true
,否则返回 false
。
如果提供的是对象,那么 predicate
将创建 _.matches
风格的回调函数,并在匹配给定对象的属性的元素时返回 true
,否则返回 false
。
参数
array
(Array) : 待检查的已整理过的数组value
(*) : 待计算的值[iteratee=_.identity]
(Function|Object|string) : 每次迭代执行的函数[thisArg]
(*) :iteratee
绑定的this
返回
(number) : 返回 value
在 array
中应该插入的索引位置
示例
_.sortedIndex([30, 50], 40);
// → 1
_.sortedIndex([4, 4, 5, 5], 5);
// → 2
var dict = { 'data': { 'thirty': 30, 'forty': 40, 'fifty': 50 } };
// 使用迭代器函数
_.sortedIndex(['thirty', 'fifty'], 'forty', function(word) {
return this.data[word];
}, dict);
// → 1
// 使用 `_.property` 回调函数简称
_.sortedIndex([{ 'x': 30 }, { 'x': 50 }], { 'x': 40 }, 'x');
// → 1
_.sortedLastIndex(array, value, [iteratee=_.identity], [thisArg])
该方法类似 _.sortedIndex
,但其返回的是 array
插入 value
的最大的索引位置。
参数
array
(Array) : 待检查的已整理的数组value
(*) : 待计算的值[iteratee=_.identity]
_(Function|Object|string)_: 每次迭代时执行的函数[thisArg]
(*) :iteratee
绑定的this
返回
(number) : 返回 value
在 array
中应该插入的索引位置
示例
_.sortedLastIndex([4, 4, 5, 5], 5);
// → 4
_.take(array, [n=1])
创建一个从 array
的起始位置开始起共 n
个元素的分片。
参数
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])
创建一个从 array
的结束位置开始起共 n
个元素的分片。
参数
array
(Array) : 待查询的数组[n=1]
(number) : 获取元素的个数
返回
(Array) : 返回 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], [thisArg])
创建一个从 array
的结束位置开始起包含若干个元素的分片。在 predicate
返回假值之前,元素都将被传入分片之中。断言函数将绑定 thisArg
并传入三个参数:value
, index
, array
。
如果提供的是属性名,那么 predicate
将创建 _.property
风格的回调函数,并返回给定元素的属性的值。
如果值还提供了 thisArg
,那么 predicate
将创建 _.matchesProperty
风格的回调,并在元素含有匹配的属性值的时候返回 true
,否则返回 false
。
如果提供的是对象,那么 predicate
将创建 _.matches
风格的回调函数,并在匹配给定对象的属性的元素时返回 true
,否则返回 false
。
参数
array
(Array) : 待查询的数组[predicate=_.identity]
(Function|Object|string) : 每次迭代执行的函数[thisArg]
(*) :predicate
绑定的this
返回
(Array) : 返回 array
的分片
示例
_.takeRightWhile([1, 2, 3], function(n) {
return n > 1;
});
// → [2, 3]
var users = [
{ 'user': 'barney', 'active': true },
{ 'user': 'fred', 'active': false },
{ 'user': 'pebbles', 'active': false }
];
// 使用 `_.matches` 回调函数简称
_.pluck(_.takeRightWhile(users, { 'user': 'pebbles', 'active': false }), 'user');
// → ['pebbles']
// 使用 `_.matchesProperty` 回调函数简称
_.pluck(_.takeRightWhile(users, 'active', false), 'user');
// → ['fred', 'pebbles']
// 使用 `_.property` 回调函数简称
_.pluck(_.takeRightWhile(users, 'active'), 'user');
// → []
_.takeWhile(array, [predicate=_.identity], [thisArg])
创建一个从 array
的起始位置开始起包含若干个元素的分片。在 predicate
返回假值之前,元素都将被传入分片之中。断言函数将绑定 thisArg
并传入三个参数:value
, index
, array
。
如果提供的是属性名,那么 predicate
将创建 _.property
风格的回调函数,并返回给定元素的属性的值。
如果值还提供了 thisArg
,那么 predicate
将创建 _.matchesProperty
风格的回调,并在元素含有匹配的属性值的时候返回 true
,否则返回 false
。
如果提供的是对象,那么 predicate
将创建 _.matches
风格的回调函数,并在匹配给定对象的属性的元素时返回 true
,否则返回 false
。
参数
array
(Array) : 待查询的数组[predicate=_.identity]
(Function|Object|string) : 每次迭代执行的函数[thisArg]
(*) :predicate
绑定的this
返回
(Array) : 返回 array
的分片
示例
_.takeWhile([1, 2, 3], function(n) {
return n < 3;
});
// → [1, 2]
var users = [
{ 'user': 'barney', 'active': false },
{ 'user': 'fred', 'active': false},
{ 'user': 'pebbles', 'active': true }
];
// 使用 `_.matches` 回调函数简称
_.pluck(_.takeWhile(users, { 'user': 'barney', 'active': false }), 'user');
// → ['barney']
// 使用 `_.matchesProperty` 回调函数简称
_.pluck(_.takeWhile(users, 'active', false), 'user');
// → ['barney', 'fred']
// 使用 `_.property` 回调函数简称
_.pluck(_.takeWhile(users, 'active'), 'user');
// → []
_.union([arrays])
创建一个含有唯一值的数组,从每个数组获取的值在插入时都会使用 SameValueZero
和归并后的数组的值进行相等性比较。
参数
[arrays]
(…Array) : 待检查的数组
返回
(Array) : 返回组合值的新数组
示例
_.union([1, 2], [4, 2], [2, 1]);
// → [1, 2, 4]
_.uniq(array, [isSorted], [iteratee], [thisArg])
Creates a duplicate-free version of an array, using SameValueZero for equality comparisons, in which only the first occurrence of each element is kept. Providing true for isSorted performs a faster search algorithm for sorted arrays. If an iteratee function is provided it’s invoked for each element in the array to generate the criterion by which uniqueness is computed. The iteratee is bound to thisArg and invoked with three arguments: (value, index, array).
如果提供的是属性名,那么 predicate
将创建 _.property
风格的回调函数,并返回给定元素的属性的值。
如果值还提供了 thisArg
,那么 predicate
将创建 _.matchesProperty
风格的回调,并在元素含有匹配的属性值的时候返回 true
,否则返回 false
。
如果提供的是对象,那么 predicate
将创建 _.matches
风格的回调函数,并在匹配给定对象的属性的元素时返回 true
,否则返回 false
。
别名
_.unique
参数
array
(Array) : 待检查的数组[isSorted]
(boolean) : 指定数组是否已整理[iteratee]
(Function|Object|string) : 每次迭代执行的函数[thisArg]
(*) :iteratee
绑定的this
返回
(Array) : 返回一个无重复值的新数组
示例
_.uniq([2, 1, 2]);
// → [2, 1]
// 使用 `isSorted`
_.uniq([1, 1, 2], true);
// → [1, 2]
// 使用迭代器函数
_.uniq([1, 2.5, 1.5, 2], function(n) {
return this.floor(n);
}, Math);
// → [1, 2.5]
// 使用 `_.property` 回调函数简称
_.uniq([{ 'x': 1 }, { 'x': 2 }, { 'x': 1 }], 'x');
// → [{ 'x': 1 }, { 'x': 2 }]
_.unzip(array)
该方法类似 _.zip
,但其接受一个含有分组元素的数组,并创建一个含有使用预压缩配置的重组元素的数组(creates an array regrouping the elements to their pre-zip configuration)。
参数
array
(Array) : 待处理的各元素数组
返回
(Array) : 返回含有重组的元素的新数组
示例
var zipped = _.zip(['fred', 'barney'], [30, 40], [true, false]);
// → [['fred', 30, true], ['barney', 40, false]]
_.unzip(zipped);
// → [['fred', 'barney'], [30, 40], [true, false]]
_.unzipWith(array, [iteratee], [thisArg])
该函数类似 _.unzip
,但其接受一个指定值应该如何结合的迭代器。iteratee
迭代器绑定 thisArg
并在执行时传入四个参数:accumulator
, value
, index
, group
。
参数
array
(Array) : 待处理的各元素数组[iteratee]
(Function) : 处理重组值的函数[thisArg]
(*) :iteratee
绑定的this
返回
(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
进行相等性比较)。
参数
array
(Array) : 待过滤的数组[values]
(…*) : 待排除的值
返回
(Array) : 返回一个含有过滤后的值的新数组
示例
_.without([1, 2, 1, 3], 1, 2);
// → [3]
_.xor([arrays])
Creates an array of unique values that is the symmetric difference of the provided arrays.
创建一个含有唯一值(每个值在各个数组中 对称差)的数组。
参数
[arrays]
(…Array) : 待检查的数组
返回
(Array) : 返回一个含有值的新数组
示例
_.xor([1, 2], [4, 2]);
// → [1, 4]
_.zip([arrays])
创建一个含有同组元素的新数组,第一个元素含有每个给定数组的第一个元素,第二个元素含有每个给定数组的第二个元素,以此类推。
参数
[arrays]
(…Array) : 待处理的数组
返回
(Array) : 返回一个含有同组元素的新数组
示例
_.zip(['fred', 'barney'], [30, 40], [true, false]);
// → [['fred', 30, true], ['barney', 40, false]]
_.zipObject(props, [values=[]])
作用与 _.pairs
相反。该方法返回一个由属性名数组和值数组组成的对象。需要提供一个长度只为 2
的数组,例如:[[key1, value1], [key2, value2]]
。或者一个为属性名的数组,另一个为属性值的数组。
别名
_.object
参数
props
(Array) : 属性名组[values=[]]
(Array) : 属性值组
返回
(Object) : 返回一个新的对象。
示例
_.zipObject([['fred', 30], ['barney', 40]]);
// → { 'fred': 30, 'barney': 40 }
_.zipObject(['fred', 'barney'], [30, 40]);
// → { 'fred': 30, 'barney': 40 }
_.zipWith([arrays], [iteratee], [thisArg])
该方法类似 _.zip
,但其接受一个指定值应该如何结合的迭代器。iteratee
迭代器绑定 thisArg
并在执行时传入四个参数:accumulator
, value
, index
, group
。
参数
[arrays]
(…Array) : 待处理的数组[iteratee]
(Function) : 处理重组值的函数[thisArg]
(*) :iteratee
绑定的this
返回
(Array) : 返回含有重组的元素的新数组
示例
_.zipWith([1, 2], [10, 20], [100, 200], _.add);
// → [111, 222]
**粗体** _斜体_ [链接](http://example.com) `代码` - 列表 > 引用
。你还可以使用@
来通知其他用户。