lodash --- 数组 Array

最新推荐文章于 2022-12-01 18:20:40 发布

Allen乀

最新推荐文章于 2022-12-01 18:20:40 发布

阅读量773

点赞数

文章标签： lodash array js

本文链接：https://blog.csdn.net/weixin_42524164/article/details/98322207

版权

1) _.chunk(array, [size=1])

将数组（array）拆分成多个 size 长度的区块，并将这些区块组成一个新数组。如果array 无法被分割成全部等长的区块，那么最后剩余的元素将组成一个区块。

参数

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

2) _.compact(array)

创建一个新数组，包含原数组中所有的非假值元素。例如false, null, 0, “”, undefined, 和 NaN 都是被认为是“假值”。

参数

array (Array): 待处理的数组

返回值

(Array): 返回过滤掉假值的新数组。


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

3）_.difference(array, [values])

创建一个具有唯一array值的数组，每个值不包含在其他给定的数组中。（即创建一个新数组，这个数组中的值，为第一个数字（array 参数）排除了给定数组中的值。）该方法使用 SameValueZero做相等比较。结果值的顺序是由第一个数组中的顺序确定。

参数

array (Array): 要检查的数组。
[values] (…Array): 排除的值。

返回值

(Array): 返回一个过滤值后的新数组。


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

4) .differenceBy(array, [values], [iteratee=.identity])

这个方法类似 _.difference ，除了它接受一个 iteratee （迭代器），调用array 和 values 中的每个元素以产生比较的标准。结果值是从第一数组中选择。iteratee 会调用一个参数：(value)。（首先使用迭代器分别迭代array 和 values中的每个元素，返回的值作为比较值）。

参数

array (Array): 要检查的数组。
[values] (…Array): 排除的值。
[iteratee=_.identity] (Array|Function|Object|string): iteratee 调用每个元素。

返回值

(Array): 返回一个过滤值后的新数组。


_.differenceBy([3.1, 2.2, 1.3], [4.4, 2.5], Math.floor);
// => [3.1, 1.3]
 
// The `_.property` iteratee shorthand.
_.differenceBy([{ 'x': 2 }, { 'x': 1 }], [{ 'x': 1 }], 'x');
// => [{ 'x': 2 }]

5）_.differenceWith(array, [values], [comparator])

这个方法类似 _.difference ，除了它接受一个 comparator （比较器），它调用比较array，values中的元素。结果值是从第一数组中选择。comparator 调用参数有两个：(arrVal, othVal)。
Note: 不像 _.pullAllWith, 这个方法会返回一个新数组。

参数

array (Array): 要检查的数组。
[values] (…Array): 排除的值。
[comparator] (Function): comparator 调用每个元素。

返回值

(Array): 返回一个过滤值后的新数组。

例子


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

6) _.drop(array, [n=1])

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

参数

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]

7) _.dropRight(array, [n=1])

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

参数

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]

8) .dropRightWhile(array, [predicate=.identity])

创建一个切片数组，去除array中从 predicate 返回假值开始到尾部的部分。predicate 会传入3个参数： (value, index, array)。

参数

array (Array): 要查询的数组。
[predicate=_.identity] (Function): 这个函数会在每一次迭代调用。

返回值

(Array): 返回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']

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

**使用 value 值来填充（替换） array，从start位置开始, 到end位置结束（但不包含end位置）。

Note: 这个方法会改变 array（不是创建新数组）。**

参数

array (Array): 要填充改变的数组。
value (*): 填充给 array 的值。
[start=0] (number): 开始位置（默认0）。
[end=array.length] (number):结束位置（默认array.length）。

返回值

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

10) .findIndex(array, [predicate=.identity], [fromIndex=0])

该方法类似 _.find，区别是该方法返回第一个通过 predicate 判断为真值的元素的索引值（index），而不是元素本身。

参数

array (Array): 要搜索的数组。
[predicate=_.identity] (Array|Function|Object|string): 这个函数会在每一次迭代调用。
[fromIndex=0] (number): The index to search from.

返回值

(number): 返回找到元素的索引值（index），否则返回 -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

11) .findLastIndex(array, [predicate=.identity], [fromIndex=array.length-1])

这个方式类似 _.findIndex，区别是它是从右到左的迭代集合array中的元素。

参数

array (Array): 要搜索的数组。
[predicate=_.identity] (Array|Function|Object|string): 这个函数会在每一次迭代调用。
[fromIndex=array.length-1] (number): The index to search from.

返回值

(number): 返回找到元素的索引值（index），否则返回 -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

12) _.flatten(array)

减少一级array嵌套深度。

参数

array (Array): 需要减少嵌套层级的数组。

返回值

(Array): 返回减少嵌套层级后的新数组。


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

13) _.flattenDeep(array)

将array递归为一维数组。

参数

array (Array): 需要处理的数组。

返回值

(Array): 返回一个的新一维数组。


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

14) _.fromPairs(pairs)

与 _.toPairs正好相反；这个方法返回一个由键值对pairs构成的对象。

参数

pairs (Array): 键值对pairs。

返回值

(Object): 返回一个新对象。


_.fromPairs([['fred', 30], ['barney', 40]]);
// => { 'fred': 30, 'barney': 40 }

15) _.indexOf(array, value, [fromIndex=0])

使用 SameValueZero 等值比较，返回首次 value 在数组array中被找到的索引值，如果 fromIndex 为负值，将从数组array尾端索引进行匹配。

参数

array (Array): 需要查找的数组。
value (*): 需要查找的值。
[fromIndex=0] (number): 开始查询的位置。

返回值

(number): 返回值value在数组中的索引位置, 没有找到为返回-1。


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

_.intersection([arrays])

创建唯一值的数组，这个数组包含所有给定数组都包含的元素，使用 SameValueZero进行相等性比较。（可以理解为给定数组的交集）

参数

[arrays] (…Array): 待检查的数组。

返回值

(Array): 返回一个包含所有传入数组交集元素的新数组。


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

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

这个方法类似 _.indexOf ，区别是它是从右到左遍历array的元素。

参数

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

_.pull(array, [values])

移除数组array中所有和给定值相等的元素，使用 SameValueZero 进行全等比较。
注意：和 _.without 方法不同，这个方法会改变数组。使用 _.remove 从一个数组中移除元素。

参数

array (Array): 要修改的数组。
[values] (…*): 要删除的值。

返回值

(Array): 返回 array.


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

_.pullAll(array, values)

这个方法类似 _.pull，区别是这个方法接收一个要移除值的数组。
Note: 不同于 _.difference, 这个方法会改变数组 array。

参数

array (Array): 要修改的数组。
values (Array): 要移除值的数组。

返回值

(Array): 返回 array。


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

.pullAllBy(array, values, [iteratee=.identity])

这个方法类似于 _.pullAll ，区别是这个方法接受一个 iteratee（迭代函数）调用 array 和 values的每个值以产生一个值，通过产生的值进行了比较。iteratee 会传入一个参数： (value)。
Note: 不同于 _.differenceBy, 这个方法会改变数组 array。

参数

array (Array): 要修改的数组。
values (Array): 要移除值的数组。
[iteratee=_.identity] (Array|Function|Object|string): iteratee（迭代器）调用每个元素。

返回值

(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比较。comparator 会传入两个参数：(arrVal, othVal)。
注意: 和 _.differenceWith 不同, 这个方法会改变数组 array。

参数

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

返回值

(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 }]

.remove(array, [predicate=.identity])

移除数组中predicate（断言）返回为真值的所有元素，并返回移除元素组成的数组。predicate（断言）会传入3个参数： (value, index, array)。
Note: 和 _.filter不同, 这个方法会改变数组 array。使用 _.pull来根据提供的value值从数组中移除元素。

参数

array (Array): 要修改的数组。
[predicate=_.identity] (Array|Function|Object|string): 每次迭代调用的函数。

返回值

(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): 要修改的数组。

返回值

(Array): 返回 array.


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

_.take(array, [n=1])

创建一个数组切片，从array数组的起始元素开始提取n个元素。

参数

array (Array): 要检索的数组。
[n=1] (number): 要提取的元素个数。

返回值

(Array): 返回 array 数组的切片（从起始元素开始n个元素）。


_.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 数组的切片（从结尾元素开始n个元素）。


_.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 返回假值。predicate 会传入三个参数： (value, index, array)。

参数

array (Array): 要检索的数组。
[predicate=_.identity] (Array|Function|Object|string): 每次迭代调用的函数。

返回值

(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 返回假值。predicate 会传入三个参数： (value, index, array)。

参数

array (Array): 需要处理的数组
[predicate=_.identity] (Array|Function|Object|string): 每次迭代调用的函数。

返回值

(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');
// => []

_.uniq(array)

创建一个去重后的array数组副本。使用了 SameValueZero 做等值比较。只有第一次出现的元素才会被保留。

参数

array (Array): 要检查的数组。

返回值

(Array): 返回新的去重后的数组。


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

.uniqBy(array, [iteratee=.identity])

这个方法类似 _.uniq ，除了它接受一个 iteratee （迭代函数），调用每一个数组（array）的每个元素以产生唯一性计算的标准。iteratee 调用时会传入一个参数：(value)。

参数

array (Array): 要检查的数组。
[iteratee=_.identity] (Array|Function|Object|string): 迭代函数，调用每个元素。

返回值

(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 }]

_.without(array, [values])

创建一个剔除所有给定值的新数组，剔除值的时候，使用 SameValueZero做相等比较。
注意: 不像 _.pull, 这个方法会返回一个新数组。

参数

array (Array): 要检查的数组。
[values] (…*): 要剔除的值。

返回值

(Array): 返回过滤值后的新数组。


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

_.xor([arrays])

创建一个给定数组唯一值的数组，使用 symmetric difference做等值比较。返回值的顺序取决于他们数组的出现顺序。

参数

[arrays] (…Array): 要检查的数组。

返回值

(Array): 返回过滤值后的新数组。


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

.xorBy([arrays], [iteratee=.identity])

这个方法类似 _.xor ，除了它接受 iteratee（迭代器），这个迭代器调用每一个 arrays（数组）的每一个值，以生成比较的新值。iteratee 调用一个参数： (value).

参数

[arrays] (…Array): 要检查的数组。
[iteratee=_.identity] (Array|Function|Object|string): 调用每一个元素的迭代函数。

返回值

(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 ，以调用比较数组的元素。 comparator 调用2个参数：(arrVal, othVal).

参数

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

创建一个分组元素的数组，数组的第一个元素包含所有给定数组的第一个元素，数组的第二个元素包含所有给定数组的第二个元素，以此类推。

参数

[arrays] (…Array): 要处理的数组。

返回值

(Array): 返回分组元素的新数组。


_.zip(['fred', 'barney'], [30, 40], [true, false]);
// => [['fred', 30, true], ['barney', 40, false]]

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

这个方法类似 _.fromPairs，除了它接受2个数组，第一个数组中的值作为属性标识符（属性名），第二个数组中的值作为相应的属性值。

参数

[props=[]] (Array): The property identifiers.
[values=[]] (Array): The property values.

返回值

(Object): Returns the new object.


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

.zipWith([arrays], [iteratee=.identity])

这个方法类似于 _.zip，不同之处在于它接受一个 iteratee（迭代函数），来指定分组的值应该如何被组合。该iteratee调用每个组的元素： (…group).

参数

[arrays] (…Array): 要处理的数组。
[iteratee=_.identity] (Function): 函数用来组合分组的值。

返回值

(Array): 返回分组元素的新数组。


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

Allen乀

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
lodash --- 数组 Array

1) _.chunk(array, [size=1])将数组（array）拆分成多个 size 长度的区块，并将这些区块组成一个新数组。如果array 无法被分割成全部等长的区块，那么最后剩余的元素将组成一个区块。参数array (Array): 需要处理的数组[size=1] (number): 每个数组区块的长度返回值(Array): 返回一个包含拆分区块的新数组（相当于一个...
复制链接

扫一扫