lodash-Array

中文官网：https://www.lodashjs.com/docs/latest

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

将数组拆分成多个 size 长度的块，并组成一个新数组。 如果数组无法被分割成全部等长的块，那么最后剩余的元素将组成一个块。
参数
array (Array): 需要处理的数组。
[size=1] (number): 每个数组区块的长度。可选参数。
返回
(Array): 返回一个包含拆分区块的新数组（相当于一个二维数组）。
原数组不变。

注：旧版本：_.chunk(array, [size=0])

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

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

// 旧版本：
console.log(_.chunk(['a', 'b', 'c', 'd'])); // [] 
// 新版本：
console.log(_.chunk(['a', 'b', 'c', 'd']))  // [['a'],['b'],['c'],['d']]

chunk
英 [tʃʌŋk]
块，组块
bundle
/ˈbʌndl/
n.捆;(一)包;(一)扎;一大笔钱;一批(同类事物或出售的货品);

2. _.compact(array)

创建一个新数组，包含原数组中所有的非假值元素。例如false, null, 0, "", undefined, 和 NaN 都是被认为是“假值”。
参数
array (Array): 待处理的数组
返回值
(Array): 返回过滤掉假值的新数组。
原数组不变。

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

compact
英 [kəmˈpækt ]
v :把…紧压在一起(或压实)
adj:小型的;袖珍的;紧凑的;体积小的;紧密的;坚实的
n:小汽车;带镜小粉盒;协定;协议;契约;合约

3. _.concat(array, [values])

创建一个新数组，将array与任何数组 或 值连接在一起。
参数
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]

注：如果是值，直接放进去；如果是数组，只会去除最外一层；

_.concat(array, 2, [3,[5]], [[4]]); // [1,2,3,[5],[4]]
_.concat(array, 2, [3,5], [[4]]); // [1,2,3,5,[4]]

_.difference(array, [values])

创建一个具有唯一array值的数组，每个值不包含在其他给定的数组中。（即创建一个新数组，这个数组中的值，为第一个数字（array 参数）排除了给定数组中的值。）

参数
array (Array): 要检查的数组。
[values] (...Array): 排除的值。
返回值
(Array): 返回一个过滤值后的新数组。

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


console.log(_.difference([3, 2, 1], [3, 2])); // [1]

注：如果数组元素为引用类型的是，如何？？

 console.log(_.difference([{x:1,y:1},{x:2,y:2},{x:3,y:3}], [{x:1}]));
 // 返回还是原数组，没有改变。 与diffrencyBy对比。

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

这个方法类似 _.difference，除了它接受一个 iteratee 调用每一个数组和值。iteratee 会传入一个参数：(value)。
参数
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]

// 使用了 `_.property` 的回调结果  The `_.property` iteratee shorthand.
_.differenceBy([{ 'x': 2 }, { 'x': 1 }], [{ 'x': 1 }], 'x');
// => [{ 'x': 2 }]

console.log(_.differenceBy([{"name":1,value:1},{"name":2,value:2}], [{"name":2,}],'name')); // [{name:1,value:1}]

⇒ 扩展场景：

1. 一个数组不包含另一个数组内的值：https://blog.csdn.net/weixin_42995876/article/details/134419395

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

这个方法类似 _.difference，除了它接受一个 comparator 调用每一个数组元素的值。 comparator 会传入2个参数：(arrVal, othVal)。

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

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

_.differenceWith(objects, [{ 'x': 1, 'y': 3 }], _.isEqual);
// => [{ 'x': 1, 'y': 2 },{ 'x': 2, 'y': 1 }]  // 全部返回，因为没有全匹配

var obj= [{ 'x': 1, 'y': 2, 'z':3 }, { 'x': 2, 'y': 1 }];
_.differenceWith(obj, [{ 'x': 1, 'y': 2 }], _.isEqual);
// => [{ 'x': 1, 'y': 2 },{ 'x': 2, 'y': 1 }]  // 全部返回，因为没有全匹配

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

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

参数
array (Array): 要查询的数组。
[n=1] (number): 要去除的元素个数。

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

注：shift只能去除数组的第一个，drop方法可以多个。

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

从右边开始裁剪数组中的 N 个数组，返回剩余的部分。

_.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 返回假值开始到尾部的部分。predicate 会传入3个参数： (value, index, 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']

var users = [
    { 'user': 'barney',  'active': true },
    { 'user': 'fred',  'active': false },
    { 'user': 'pebbles', 'active': true }
];
console.log(_.dropRightWhile(users, function (o) {
    return o.active;
}));
// => objects for ['barney','fred']

注：有一个假值开始，后面不判断了，直接全部返回。
当返回为false时，从此之后，全部抛弃。

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

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

var users = [
    { 'user': 'barney',  'active': true },
    { 'user': 'fred',    'active': false },
    { 'user': 'pebbles', 'active': true }
];
console.log(_.dropWhile(users, function (o) {
    return !o.active;
}));
// => 全部返回

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

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

注：这个方法会改变 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 判断为真值的元素的 index ，而不是元素本身。返回符合元素的 index，否则返回 -1。

var users = [
  { 'user': 'barney',  'active': false },
  { 'user': 'fred',    'active': false },
  { 'user': 'pebbles', 'active': true },
  { 'user': 'barney',  'active': true }
];

_.findIndex(users, function(o) { return o.user == 'barney'; });
// => 0


_.findIndex(users, function (o) { return o.user == 'barney'; },2)
// 3

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

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

var users = [
  { 'user': 'barney',  'active': true },
  { 'user': 'fred',    'active': false },
  { 'user': 'pebbles', 'active': false }
];

_.findLastIndex(users, function(o) { return o.user == 'pebbles'; });
// => 2

_.flatten(array)

减少一级array嵌套深度。

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

_.flattenDeep(array)

将array递归为一维数组。

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

_.flattenDepth(array, [depth=1])

根据 depth 递归减少 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构成的对象。

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

_.head(array)

获取数组 array 的第一个元素。别名:_.first

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

_.head([]);
// => undefined

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

根据 value 使用 SameValueZero 等值比较返回数组中首次匹配的 index， 如果 fromIndex 为负值，将从数组尾端索引进行匹配，如果将 fromIndex 设置为 true，将使用更快的二进制检索机制。返回匹配值的index，否则返回 -1。

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

// 使用了 `fromIndex`
_.indexOf([1, 2, 1, 2], 2, 2);
// => 3

• _.initial()

获取数组中除了最后一个元素之外的所有元素，返回没有最后一个元素的数组

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

注：跟pop一样？

_.intersection([arrays])

创建一个包含所有使用 SameValueZero 进行等值比较后筛选的唯一值数组。返回数组中所有数组共享元素的新数组

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

注：与difference相反？

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

这个方法类似 _.intersection，除了它接受一个 iteratee 调用每一个数组和值。iteratee 会传入一个参数：(value)，返回数组中共享元素的新数组。

_.intersectionBy([2.1, 1.2], [4.3, 2.4], Math.floor);
// => [2.1]

// 使用了 `_.property` 的回调结果
_.intersectionBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x');
// => [{ 'x': 1 }] 


_.intersectionBy([{'x': 1, y: 3,z:'z'},{x:3}], [{'x': 2}, {'x': 1}], 'x')
// [{'x': 1, y: 3,z:'z'}]   // 返回第一个参数的项；如果后面的多了key，那么没用；

_.intersectionBy([{'x': 1},{x:3}], [{'x': 2}, {'x': 1, y: 3,z:'z'}], 'x')
// ([{'x': 1}]

• _.intersectionWith([arrays], [comparator])

这个方法类似 _.intersection，除了它接受一个 comparator 调用每一个数组和值。iteratee 会传入2个参数：((arrVal, othVal)，返回数组中共享元素的新数组。

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=‘,’])

将数组中的所有元素转换为由 separator 分隔的字符串。返回连接好的字符串

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

• _.last(array)

获取数组中的最后一个元素，返回数组中的最后一个元素。

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

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

这个方法类似 _.indexOf，除了它是从右到左遍历元素的。 这个方法类似 _.indexOf except that it iterates over elements of array from right to left.返回匹配元素的 index，否则返回 -1

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

// 使用了 `fromIndex`
_.lastIndexOf([1, 2, 1, 2], 2, 2);
// => 1

• _.nth(array, [n=0])

获取array数组的第n个元素。如果n为负数，则返回从数组结尾开始的第n个元素。

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

• _.prototype.reverse()

反转数组，第一个元素移动到最后一位，第二个元素移动到倒数第二，类似这样。 注意: 这个方法会改变数组，根据 Array#reverse

var array = [1, 2, 3];

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

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

• _.pull(array, [values])

移除所有经过 SameValueZero 等值比较为 true 的元素 ，返回数组本身

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

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

• _.pullAll(array, values)

这个方式类似 _.pull，除了它接受数组形式的一系列值。返回数组本身

注意: 不同于 _.difference，这个方法会改变数组。

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

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

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

这个方法类似 _.pullAll，除了它接受一个 comparator 调用每一个数组元素的值。 comparator 会传入一个参数：(value)。
注意: 不同于 _.differenceBy，这个方法会改变数组。返回数组本身

var array = [{ 'x': 1 }, { 'x': 2 }, { 'x': 3 }, { 'x': 1 }];

_.pullAllBy(array, [{ 'x': 1 }, { 'x': 3 }], 'x');
console.log(array);
// => [{ 'x': 2 }]

• _.pullAt(array, [indexes])

根据给的 indexes 移除对应的数组元素并返回被移除的元素。

注意: 不同于 _.at，这个方法会改变数组。返回被移除的元素数组

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

移除经过 predicate 处理为真值的元素，并返回被移除的元素。predicate 会传入3个参数：(value, index, array)

注意: Unlike _.filter，这个方法会改变数组。返回被移除的元素的数组。

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]

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

创建一个裁剪后的数组，从 start 到 end 的位置，但不包括 end 本身的位置。

注意: 这个方法用于代替 Array#slice 来确保数组正确返回，返回裁剪后的数组。

• _.tail(array)

获取数组中除了第一个元素的剩余数组，

返回数组中除了第一个元素的剩余数组。

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

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

从数组的起始元素开始提取 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])

从数组的结束元素开始提取 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])

从数组的最右边开始提取数组，直到 predicate 返回假值。predicate 会传入三个参数：(value, index, array)。返回提取的元素数组

var users = [
    { 'user': 'barney',  'active': true },
    { 'user': 'fred',    'active': false },
    { 'user': 'pebbles', 'active': false }
];

console.log(_.takeRightWhile(users, function (o) {
    return !o.active;
}));
// => 结果:  [{ 'user': 'fred',    'active': false },{ 'user': 'pebbles', 'active': false }]

// 使用了 `_.matches` 的回调处理
console.log(_.takeRightWhile(users, {'user': 'pebbles', 'active': false}));
// => 结果:  [{ 'user': 'pebbles', 'active': false }]

// 使用了 `_.matchesProperty` 的回调处理
console.log(_.takeRightWhile(users, ['active', false]));
// => 结果:   [{ 'user': 'fred',    'active': false },{ 'user': 'pebbles', 'active': false }]

// 使用了 `_.property` 的回调处理
console.log(_.takeRightWhile(users, 'active'));
// => []

• .takeWhile(array, [predicate=.identity])

从数组的开始提取数组，直到 predicate 返回假值。predicate 会传入三个参数：(value, index, 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']

// 使用了 `_.matches` 的回调处理
_.takeWhile(users, { 'user': 'barney', 'active': false });
// =>结果: ['barney']

// 使用了 `_.matchesProperty` 的回调处理
_.takeWhile(users, ['active', false]);
// =>结果: ['barney', 'fred']

// 使用了 `_.property` 的回调处理
_.takeWhile(users, 'active');
// => []

• _.union([arrays])

创建顺序排列的唯一值组成的数组。所有值经过 SameValueZero 等值比较。返回处理好的数组

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

• .unionBy([arrays], [iteratee=.identity])

这个方法类似 _.union，除了它接受一个 iteratee 调用每一个数组和值。iteratee 会传入一个参数：(value)。返回处理好的数组

_.unionBy([2.1, 1.2], [4.3, 2.4], Math.floor);
// => [2.1, 1.2, 4.3]

// 使用了 `_.property` 的回调结果
_.unionBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x');
// => [{ 'x': 1 }, { 'x': 2 }]

• _.unionWith([arrays], [comparator])

这个方法类似 _.union， 除了它接受一个 comparator 调用每一个数组元素的值。 comparator 会传入2个参数：(arrVal, othVal)。返回处理好的数组

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 等值比较。只有首次出现的元素才会被保留。返回不重复的数组

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

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

这个方法类似 _.uniq，除了它接受一个 iteratee 调用每一个数组和值来计算唯一性。iteratee 会传入一个参数：(value)。返回不重复的数组

_.uniqBy([2.1, 1.2, 2.3], Math.floor);
// => [2.1, 1.2]

// 使用了 `_.property` 的回调结果
_.uniqBy([{ 'x': 1 }, { 'x': 2 }, { 'x': 1 }], 'x');
// => [{ 'x': 1 }, { 'x': 2 }]

• _.uniqWith(array, [comparator])

这个方法类似 _.uniq，除了它接受一个 comparator 来比较计算唯一性。 comparator 会传入2个参数：(arrVal, othVal)，返回不重复的数组。

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，除了它接收一个打包后的数组并且还原为打包前的状态。返回一个解包后的数组

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=.identity])

这个方法类似 _.unzip，除了它接受一个 iteratee 来决定如何重组解包后的数组。iteratee 会传入4个参数：(accumulator, value, index, group)。每组的第一个元素作为初始化的值，返回一个解包后的数组。

• .unzipWith(array, [iteratee=.identity])

这个方法类似 _.unzip，除了它接受一个 iteratee 来决定如何重组解包后的数组。iteratee 会传入4个参数：(accumulator, value, index, group)。每组的第一个元素作为初始化的值

var zipped = _.zip([1, 2], [10, 20], [100, 200]);
// => [[1, 10, 100], [2, 20, 200]]

_.unzipWith(zipped, _.add);
// => [3, 30, 300]

• _.without(array, [values])

创建一个移除了所有提供的 values 的数组。使用了 SameValueZero 等值比较。

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

_.xor([arrays])

创建一个包含了所有唯一值的数组。使用了 symmetric difference 等值比较。

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

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

• _.xorWith([arrays], [comparator])

• _.zip([arrays])

创建一个打包所有元素后的数组。第一个元素包含所有提供数组的第一个元素，第二个包含所有提供数组的第二个元素，以此类推。

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

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

这个方法类似 _.fromPairs，除了它接受2个数组，一个作为属性名，一个作为属性值。

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

• _.zipObjectDeep([props=[]], [values=[]])
• _.zipWith([arrays])