数组方法 Array Methods

Lodash v4 数组的使用方法

_.chunk

创建一个元素数组，按照“size”的长度分组。如果 array 不能被平均分割，最后的块将是剩余的元素。

引入版本 3.0.0

source / npm package

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

arry (Array): 要处理的数组。
[size=1] (number): 每个块的长度

(Array): 返回新的块数组。

示例

_.chunk(['a', 'b', 'c', 'd'], 2)
_.chunk(['a', 'b', 'c', 'd'], 3)

_.compact

创建一个删除所有错误值的数组。值 false、null、0、""、undefined 和 NaN 是错误的。

引入版本 0.1.0

source / npm package

参数 `_.compact(array)`

array (Array): 要压的数组。

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

示例

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

_.concat

创建一个新数组，将 array 与任何其他数组和/或值连接起来。

引入版本 4.0.0

source / npm package

参数 `(array, [values])`

array (Array): 要连接的数组。
[values] (...*): 要连接的值。

(Array): 返回新的串联数组。

示例

const array = [1]
const other = _.concat(array, 2, [3], [[4]])
console.log(other)
console.log(array)

_.difference

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

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

引入版本 0.1.0

source / npm package

参数 `(array, [values])`

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

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

示例

_.difference([2, 1], [2, 3])

_.differenceBy

此方法类似于 _.difference，只是它接受为 array 和 values 的每个元素调用的 iteratee 生成比较它们的标准。结果值的顺序和引用由第一个数组确定。使用一个参数调用 iteratee： (value).

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

引入版本 4.0.0

source / npm package

参数 `(array, [values], [iteratee=_.identity])`

array (Array): 要检查的数组。
[values] (...Array): 要排除的值。
[iteratee=_.identity] (Function): 每个元素调用的迭代对象。

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

示例

_.differenceBy([2.1, 1.2], [2.3, 3.4], Math.floor)
_.differenceBy([{ x: 2 }, { x: 1 }], [{ x: 1 }], 'x')

_.differenceWith

这个方法类似于 _.difference，除了它接受 comparator 来比较 array 的元素和 values。结果值的顺序和引用由第一个数组确定。比较器使用两个参数调用：(arrVal, othVal)。

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

引入版本 4.0.0

source / npm package

参数 `(array, [values], [comparator])`

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

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

示例

const objects = [{ x: 1, y: 2 }, { x: 2, y: 1 }]
_.differenceWith(objects, [{ x: 1, y: 2 }], _.isEqual)

_.drop

创建一个 array 切片，其中从开头删除了 n 个元素。

引入版本 0.5.0

source / npm package

参数 `(array, [n=1])`

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

(Array): 返回 array 的切片。

示例

_.drop([1, 2, 3])
_.drop([1, 2, 3], 2)
_.drop([1, 2, 3], 5)
_.drop([1, 2, 3], 0)

_.dropRight

创建一个 array 切片，其中从末尾删除了 n 个元素。

引入版本 3.0.0

source / npm package

参数 `(array, [n=1])`

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

(Array): 返回 array 的切片。

示例

_.dropRight([1, 2, 3])
_.dropRight([1, 2, 3], 2)
_.dropRight([1, 2, 3], 5)
_.dropRight([1, 2, 3], 0)

_.dropRightWhile

创建一个 array 的切片，不包括从末尾删除的元素。元素被删除，直到 predicate 返回 false。谓词使用三个参数调用：(value, index, array)。

引入版本 3.0.0

source / npm package

参数 `(array, [predicate=_.identity])`

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

(Array): 返回 array 的切片。

示例

const users = [
  { user: 'barney',  active: true },
  { user: 'fred',    active: false },
  { user: 'pebbles', active: false },
]
_.dropRightWhile(users, (o) => { return !o.active })
_.dropRightWhile(users, { user: 'pebbles', active: false })
_.dropRightWhile(users, ['active', false])
_.dropRightWhile(users, 'active')

_.dropWhile

创建一个 array 的切片，不包括从开头删除的元素。元素被删除，直到 predicate 返回 false。谓词使用三个参数调用：(value, index, array)。

引入版本 3.0.0

source / npm package

参数 `(array, [predicate=_.identity])`

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

(Array)：返回 array 的切片。

示例

const users = [
  { user: 'barney',  active: false },
  { user: 'fred',    active: false },
  { user: 'pebbles', active: true }
]
_.dropWhile(users, (o) => { return !o.active })
_.dropWhile(users, { user: 'barney', active: false })
_.dropWhile(users, ['active', false])
_.dropWhile(users, 'active')

_.fill

从 start 到但不包括 end 用 value 填充 array 的元素。

注意： 此方法会改变 array。

引入版本 3.2.0

source / npm package

参数 `(array, value, [start=0], [end=array.length])`

array (Array): 要填充的数组。
value (*): 用于填充 array 的值。
[start=0] (number): 起始位置。
[end=array.length] (number): 结束位置。

(Array): 返回 array.

示例

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

_.findIndex

此方法类似于 _.find，只是它返回第一个元素的索引 predicate 返回truthy for 而不是元素本身。

引入版本 1.1.0

source / npm package

参数 `(array, [predicate=_.identity], [fromIndex=0])`

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

(number): 返回找到的元素的索引，否则为 -1。

示例

const users = [
  { user: 'barney', active: false },
  { user: 'fred', active: false },
  { user: 'pebbles', active: true }
]
_.findIndex(users, (o) => { return o.user == 'barney' })
_.findIndex(users, { user: 'fred', active: false })
_.findIndex(users, ['active', false])
_.findIndex(users, 'active')

_.findLastIndex

此方法类似于 _.findIndex，只是它从右到左迭代 collection 的元素。

引入版本 2.0.0

source / npm package

参数 `(array, [predicate=_.identity], [fromIndex=array.length-1])`

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

(number): 返回找到的元素的索引，否则为 -1。

示例

const users = [
  { user: 'barney',  active: true },
  { user: 'fred',    active: false },
  { user: 'pebbles', active: false },
]
_.findLastIndex(users, (o) => { return o.user == 'pebbles' })
_.findLastIndex(users, { user: 'barney', active: true })
_.findLastIndex(users, ['active', false])
_.findLastIndex(users, 'active')

_.flatten

将 array 展平单层深度。

引入版本 0.1.0

source / npm package

参数 `(array)`

array (Array): 要展平的阵列。

(Array): 返回新的展平数组。

示例

_.flatten([1, [2, [3, [4]], 5]])

_.flattenDeep

递归地展平array。

引入版本 3.0.0

source / npm package

参数 `(array)`

array (Array): 要展平的阵列。

(Array): 返回新的展平数组。

示例

_.flattenDeep([1, [2, [3, [4]], 5]])

_.flattenDepth

递归地将 array 展平到 depth 次。

引入版本 4.4.0

source / npm package

参数 `(array, [depth=1])`

array (Array): 要展平的阵列。
[depth=1] (number): 最大递归深度。

(Array): 返回新的展平数组。

示例

const array = [1, [2, [3, [4]], 5]]
_.flattenDepth(array, 1)
_.flattenDepth(array, 2)

_.fromPairs

_.toPairs的倒数；此方法返回一个由键值对组成的对象。

引入版本 4.0.0

source / npm package

参数 `(pairs)`

pairs (Array): 键值对。

(Object): 返回新对象。

示例

_.fromPairs([['a', 1], ['b', 2]])

_.head

获取 array 的第一个元素。

引入版本 0.1.0

source / npm package

Aliases

_.first

参数 `(array)`

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

(*): 返回 array 的第一个元素。

示例

_.head([1, 2, 3])
_.head([])

_.indexOf

使用 SameValueZero 获取在 array 中找到第一次出现 value 的索引以进行相等比较。如果 fromIndex 为负数，则用作距 array 末尾的偏移量。

引入版本 0.1.0

source / npm package

参数 `(array, value, [fromIndex=0])`

array (Array): 要检查的数组。
value (*): 要搜索的值。
[fromIndex=0] (number): 要从中搜索的索引。

(number): 返回匹配值的索引，否则为 -1。

示例

_.indexOf([1, 2, 1, 2], 2)
_.indexOf([1, 2, 1, 2], 2, 2)

_.initial

获取 array 的最后一个元素以外的所有元素。

引入版本 0.1.0

source / npm package

参数 `(array)`

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

(Array): 返回 array 的切片。

示例

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

_.intersection

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

引入版本 0.1.0

source / npm package

参数 `([arrays])`

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

(Array): 返回相交值的新数组。

示例

_.intersection([2, 1], [2, 3])

_.intersectionBy

此方法类似于 _.intersection，除了它接受为每个 arrays 的每个元素调用以生成标准的 iteratee 通过它们进行比较。结果值的顺序和引用由第一个数组确定。使用一个参数调用 iteratee：(value).

引入版本 4.0.0

source / npm package

参数 `([arrays], [iteratee=_.identity])`

[arrays] (...Array): 要检查的数组。
[iteratee=_.identity] (Function): 每个元素调用的迭代对象。

(Array): 返回相交值的新数组。

示例

_.intersectionBy([2.1, 1.2], [2.3, 3.4], Math.floor)
_.intersectionBy([{ x: 1 }], [{ x: 2 }, { x: 1 }], 'x')

_.intersectionWith

此方法类似于 _.intersection，不同之处在于它接受调用以比较 arrays 的元素的 comparator。结果值的顺序和引用由第一个数组确定。比较器使用两个参数调用：(arrVal, othVal)。

引入版本 4.0.0

source / npm package

参数 `([arrays], [comparator])`

[arrays] (...Array): 要检查的数组。
[comparator] (Function): 每个元素调用的比较器。

(Array): 返回相交值的新数组。

示例

const objects = [{ x: 1, y: 2 }, { x: 2, y: 1 }]
const others = [{ x: 1, y: 1 }, { x: 1, y: 2 }]
_.intersectionWith(objects, others, _.isEqual)

_.join

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

引入版本 4.0.0

source / npm package

参数 `(array, [separator=','])`

array (Array): 要转换的数组。
[separator=','] (string): 元素分隔符。

(string): 返回连接的字符串。

示例

_.join(['a', 'b', 'c'], '~')

_.last

获取 array 的最后一个元素。

引入版本 0.1.0

source / npm package

参数 `(array)`

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

(*): 返回 array 的最后一个元素。

示例

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

_.lastIndexOf

此方法类似于 _.indexOf，只是它从右到左迭代 array 的元素。

引入版本 0.1.0

source / npm package

参数 `(array, value, [fromIndex=array.length-1])`

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

(number): 返回匹配值的索引，否则为 -1。

示例

_.lastIndexOf([1, 2, 1, 2], 2)
_.lastIndexOf([1, 2, 1, 2], 2, 2)

_.nth

获取 array 的索引 n 处的元素。如果 n 为负数，则返回倒数第 n 个元素。

引入版本 4.11.0

source / npm package

参数 `(array, [n=0])`

array (Array): 要查询的数组。
[n=0] (number): 要返回的元素的索引。

(*): 返回 array 的第 n 个元素。

示例

const array = ['a', 'b', 'c', 'd']
_.nth(array, 1)
_.nth(array, -2)

_.pull

使用 SameValueZero 从 array 中删除所有给定值以进行相等比较。

注意： 与 _.without 不同，此方法会改变 array。使用 _.remove 通过谓词从数组中删除元素。

引入版本 2.0.0

source / npm package

参数 `(array, [values])`

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

(Array): 返回“数组”。

示例

const array = ['a', 'b', 'c', 'a', 'b', 'c']
_.pull(array, 'a', 'c')
console.log(array)

_.pullAll

此方法类似于 _.pull，只是它接受要删除的值数组。

注意： 与 _.difference 不同，此方法会改变 array。

引入版本 4.0.0

source / npm package

参数 `(array, values)`

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

(Array): 返回array。

示例

const array = ['a', 'b', 'c', 'a', 'b', 'c']
_.pullAll(array, ['a', 'c'])
console.log(array)

_.pullAllBy

此方法类似于 _.pullAll，除了它接受为 array 和 values 的每个元素调用的 iteratee 生成比较它们的标准。使用一个参数调用迭代对象：(value)。

注意： 与 _.differenceBy 不同，此方法会改变 array。

引入版本 4.0.0

source / npm package

参数 `(array, values, [iteratee=_.identity])`

array (Array): 要修改的数组。
values (Array): 要删除的值。
[iteratee=_.identity] (Function): 每个元素调用的迭代对象。

(Array): 返回array。

示例

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

_.pullAllWith

This method is like _.pullAll except that it accepts comparator which is invoked to compare elements of array to values. The comparator is invoked with two arguments: (arrVal, othVal).

Note: Unlike _.differenceWith, this method mutates array.

引入版本 4.6.0

source / npm package

参数 `(array, values, [comparator])`

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

(Array): 返回 array.

示例

const array = [{ x: 1, y: 2 }, { x: 3, y: 4 }, { x: 5, y: 6 }]
_.pullAllWith(array, [{ x: 3, y: 4 }], _.isEqual)
console.log(array)

_.pullAt

从 array 中删除与 indexes 对应的元素，并返回一个已删除元素的数组。

注意： 与 _.at 不同，此方法会改变 array。

引入版本 3.0.0

source / npm package

参数 `(array, [indexes])`

array (Array): 要修改的数组。
[indexes] (...(number|number[])): 要删除的元素的索引。

(Array): 返回已删除元素的新数组。

示例

const array = ['a', 'b', 'c', 'd']
const pulled = _.pullAt(array, [1, 3])
console.log(array)
console.log(pulled)

_.remove

从 array 中删除所有 predicate 为其返回真值的元素，并返回已删除元素的数组。谓词使用三个参数调用：(value, index, array)。

注意： 与 _.filter 不同，此方法会改变 array。使用 _.pull 按值从数组中提取元素。

引入版本 2.0.0

source / npm package

参数 `(array, [predicate=_.identity])`

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

(Array): 返回已删除元素的新数组。

示例

const array = [1, 2, 3, 4]
const evens = _.remove(array, (n) => {  return n % 2 == 0 })
console.log(array)
console.log(evens)

_.reverse

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

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

引入版本 4.0.0

source / npm package

参数 `(array)`

array (Array): 要修改的数组。

(Array): 返回 array.

示例

const array = [1, 2, 3]
_.reverse(array)
console.log(array)

_.slice

创建从 start 到但不包括 end 的 array 切片。

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

引入版本 3.0.0

source / npm package

参数 `(array, [start=0], [end=array.length])`

array (Array): 要切片的数组。
[start=0] (number): 起始位置。
[end=array.length] (number): 结束位置。

(Array): 返回 array 的切片。

_.sortedIndex

使用二进制搜索来确定 value 应该插入到 array 的最低索引，以保持其排序顺序。

引入版本 0.1.0

source / npm package

参数 `(array, value)`

array (Array): 要检查的排序数组。
value (*): 要评估的值。

(number): 返回 value 应该插入 array 的索引。

示例

_.sortedIndex([30, 50], 40)

_.sortedIndexBy

此方法类似于 _.sortedIndex，除了它接受为 value 调用的 iteratee 和 array 的每个元素计算他们的排序排名。使用一个参数调用迭代对象：(value)。

引入版本 4.0.0

source / npm package

参数 `(array, value, [iteratee=_.identity])`

array (Array): 要检查的排序数组。
value (*): 要评估的值。
[iteratee=_.identity] (Function): 每个元素调用的迭代对象。

(number): 返回 value 应该插入 array 的索引。

示例

const objects = [{ x: 4 }, { x: 5 }]
_.sortedIndexBy(objects, { x: 4 }, (o) => { return o.x })
_.sortedIndexBy(objects, { x: 4 }, 'x')

_.sortedIndexOf

此方法类似于 _.indexOf，只是它对已排序的 array 执行二进制搜索。

引入版本 4.0.0

source / npm package

参数 `(array, value)`

array (Array): 要检查的数组。
value (*): 要搜索的值。

(number): 返回匹配值的索引，否则为 -1。

示例

_.sortedIndexOf([4, 5, 5, 5, 6], 5)

_.sortedLastIndex

此方法类似于 _.sortedIndex，只是它返回应将 value 插入 array 的最高索引，以便保持其排序顺序。

引入版本 3.0.0

source / npm package

参数 `(array, value)`

array (Array): 要检查的排序数组。
value (*): 要评估的值。

(number): 返回 value 应该插入 array 的索引。

示例

_.sortedLastIndex([4, 5, 5, 5, 6], 5)

_.sortedLastIndexBy

此方法类似于 _.sortedLastIndex，除了它接受为 value 调用的 iteratee 和 array 的每个元素计算他们的排序排名。使用一个参数调用迭代对象：(value)。

引入版本 4.0.0

source / npm package

参数 `(array, value, [iteratee=_.identity])`

array (Array): 要检查的排序数组。
value (*): 要评估的值。
[iteratee=_.identity] (Function): 每个元素调用的迭代对象。

(number): 返回 value 应该插入 array 的索引。

示例

const objects = [{ x: 4 }, { x: 5 }]
_.sortedLastIndexBy(objects, { x: 4 }, (o) => { return o.x })
_.sortedLastIndexBy(objects, { x: 4 }, 'x')

_.sortedLastIndexOf

此方法类似于 _.lastIndexOf，只是它对已排序的 array 执行二进制搜索。

引入版本 4.0.0

source / npm package

参数 `(array, value)`

array (Array): 要检查的数组。
value (*): 要搜索的值。

(number): 返回匹配值的索引，否则为 -1。

示例

_.sortedLastIndexOf([4, 5, 5, 5, 6], 5)

_.sortedUniq

此方法类似于 _.uniq，只是它是为排序数组设计和优化的。

引入版本 4.0.0

source / npm package

参数 `(array)`

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

(Array): 返回新的重复自由数组。

示例

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

_.sortedUniqBy

此方法类似于 _.uniqBy，只是它是为排序数组设计和优化的。

引入版本 4.0.0

source / npm package

参数 `(array, [iteratee])`

array (Array): 要检查的数组。
[iteratee] (Function): 每个元素调用的迭代对象。

(Array): 返回新的重复自由数组。

示例

_.sortedUniqBy([1.1, 1.2, 2.3, 2.4], Math.floor)

_.tail

获取 array 的第一个元素以外的所有元素。

引入版本 4.0.0

source / npm package

参数 `(array)`

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

(Array): 返回 array 的切片。

示例

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

_.take

使用从开头获取的 n 个元素创建一个 array 切片。

引入版本 0.1.0

source / npm package

参数 `(array, [n=1])`

array (Array): 要查询的数组。
[n=1] (number): 要采取的元素数量。

(Array): 返回 array 的切片。

示例

_.take([1, 2, 3])
_.take([1, 2, 3], 2)
_.take([1, 2, 3], 5)
_.take([1, 2, 3], 0)

_.takeRight

创建一个 array 切片，其中包含从末尾获取的 n 个元素。

引入版本 3.0.0

source / npm package

参数 `(array, [n=1])`

array (Array): 要查询的数组。
[n=1] (number): 要采取的元素数量。

(Array): 返回 array 的切片。

示例

_.takeRight([1, 2, 3])
_.takeRight([1, 2, 3], 2)
_.takeRight([1, 2, 3], 5)
_.takeRight([1, 2, 3], 0)

_.takeRightWhile

使用从末尾获取的元素创建一个 array 切片。元素被取走，直到 predicate 返回 false。谓词使用三个参数调用：(value, index, array)。

引入版本 3.0.0

source / npm package

参数 `(array, [predicate=_.identity])`

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

(Array): 返回 array 的切片。

示例

const users = [{ user: 'barney',  active: true },  { user: 'fred',    active: false },  { user: 'pebbles', active: false }]
_.takeRightWhile(users, (o) => { return !o.active })
_.takeRightWhile(users, { user: 'pebbles', active: false })
_.takeRightWhile(users, ['active', false])
_.takeRightWhile(users, 'active')

_.takeWhile

使用从头开始的元素创建一个 array 切片。元素被取走，直到 predicate 返回 false。谓词使用三个参数调用：(value, index, array)。

引入版本 3.0.0

source / npm package

参数 `(array, [predicate=_.identity])`

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

(Array): 返回 array 的切片。

示例

const users = [
  { user: 'barney',  active: false },
  { user: 'fred',    active: false },
  { user: 'pebbles', active: true },
]
_.takeWhile(users, (o) => { return !o.active })
_.takeWhile(users, { user: 'barney', active: false })
_.takeWhile(users, ['active', false])
_.takeWhile(users, 'active')

_.union

使用 SameValueZero 从所有给定数组中按顺序创建唯一值数组以进行相等比较。

引入版本 0.1.0

source / npm package

参数 `([arrays])`

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

(Array): 返回新的组合值数组。

示例

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

_.unionBy

此方法类似于 _.union，除了它接受为每个 arrays 的每个元素调用以生成标准的 iteratee 通过它计算唯一性。结果值是从出现该值的第一个数组中选择的。使用一个参数调用迭代对象：(value)。

引入版本 4.0.0

source / npm package

参数 `([arrays], [iteratee=_.identity])`

[arrays] (...Array): 要检查的数组。
[iteratee=_.identity] (Function): 每个元素调用的迭代对象。

(Array): 返回新的组合值数组。

示例

_.unionBy([2.1], [1.2, 2.3], Math.floor)
_.unionBy([{ x: 1 }], [{ x: 2 }, { x: 1 }], 'x')

_.unionWith

此方法与 _.union 类似，不同之处在于它接受被调用以比较 arrays 元素的 comparator。结果值是从出现该值的第一个数组中选择的。使用两个参数调用比较器：(arrVal, othVal)。

引入版本 4.0.0

source / npm package

参数 `([arrays], [comparator])`

[arrays] (...Array): 要检查的数组。
[comparator] (Function): 每个元素调用的比较器。

(Array): 返回新的组合值数组。

示例

const objects = [{ x: 1, y: 2 }, { x: 2, y: 1 }]
const others = [{ x: 1, y: 1 }, { x: 1, y: 2 }]
_.unionWith(objects, others, _.isEqual)

_.uniq

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

引入版本 0.1.0

source / npm package

参数 `(array)`

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

(Array): 返回新的重复自由数组。

示例

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

_.uniqBy

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

引入版本 4.0.0

source / npm package

参数 `(array, [iteratee=_.identity])`

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

(Array): 返回新的重复自由数组。

示例

_.uniqBy([2.1, 1.2, 2.3], Math.floor)
_.uniqBy([{ x: 1 }, { x: 2 }, { x: 1 }], 'x')

_.uniqWith

此方法类似于 _.uniq，只是它接受调用以比较 array 的元素的 comparator。结果值的顺序由它们在数组中出现的顺序决定。比较器使用两个参数调用：(arrVal, othVal)。

引入版本 4.0.0

source / npm package

参数 `(array, [comparator])`

array (Array): 要检查的数组。
[comparator] (Function): 每个元素调用的比较器。

(Array): 返回新的重复自由数组。

示例

const objects = [{ x: 1, y: 2 }, { x: 2, y: 1 }, { x: 1, y: 2 }]
_.uniqWith(objects, _.isEqual)

_.unzip

此方法类似于 _.zip，不同之处在于它接受一个分组元素数组并创建一个数组，将元素重新组合到其预压缩配置 .

引入版本 1.2.0

source / npm package

参数 `(array)`

array (Array): 要处理的分组元素数组。

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

示例

const zipped = _.zip(['a', 'b'], [1, 2], [true, false])
_.unzip(zipped)

_.unzipWith

此方法类似于 _.unzip，只是它接受 iteratee 来指定应如何组合重新分组的值。使用每个组的元素调用迭代对象：(...group)。

引入版本 3.8.0

source / npm package

参数 `(array, [iteratee=_.identity])`

array (Array): 要处理的分组元素数组。
[iteratee=_.identity] (Function): 组合重新组合的值的功能。

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

示例

const zipped = _.zip([1, 2], [10, 20], [100, 200])
_.unzipWith(zipped, _.add)

_.without

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

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

引入版本 0.1.0

source / npm package

参数 `(array, [values])`

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

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

示例

_.without([2, 1, 2, 3], 1, 2)

_.xor

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

引入版本 2.4.0

source / npm package

参数 `([arrays])`

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

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

示例

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

_.xorBy

此方法类似于 _.xor，除了它接受为每个 arrays 的每个元素调用以生成标准的 iteratee 比较它们的依据。结果值的顺序由它们在数组中出现的顺序决定。使用一个参数调用迭代对象：(value)。

引入版本 4.0.0

source / npm package

参数 `([arrays], [iteratee=_.identity])`

[arrays] (...Array): 要检查的数组。
[iteratee=_.identity] (Function): 每个元素调用的迭代对象。

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

示例

_.xorBy([2.1, 1.2], [2.3, 3.4], Math.floor)
_.xorBy([{ x: 1 }], [{ x: 2 }, { x: 1 }], 'x')

_.xorWith

此方法类似于 _.xor，只是它接受调用以比较 arrays 的元素的comparator。结果值的顺序由它们在数组中出现的顺序决定。比较器使用两个参数调用：(arrVal, othVal)。

引入版本 4.0.0

source / npm package

参数 `([arrays], [comparator])`

[arrays] (...Array): 要检查的数组。
[comparator] (Function): 每个元素调用的比较器。

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

示例

const objects = [{ x: 1, y: 2 }, { x: 2, y: 1 }]
const others = [{ x: 1, y: 1 }, { x: 1, y: 2 }]
_.xorWith(objects, others, _.isEqual)

_.zip

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

引入版本 0.1.0

source / npm package

参数 `([arrays])`

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

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

示例

_.zip(['a', 'b'], [1, 2], [true, false])

_.zipObject

此方法类似于 _.fromPairs，只是它接受两个数组，一个属性标识符和一个对应值。

引入版本 0.4.0

source / npm package

参数 `([props=[]], [values=[]])`

[props=[]] (Array): 属性标识符。
[values=[]] (Array): 属性值。

(Object): 返回新对象。

示例

_.zipObject(['a', 'b'], [1, 2])

_.zipObjectDeep

此方法类似于 _.zipObject，只是它支持属性路径。

引入版本 4.1.0

source / npm package

参数 `([props=[]], [values=[]])`

[props=[]] (Array): 属性标识符。
[values=[]] (Array): 属性值。

(Object): 返回新对象。

示例

_.zipObjectDeep(['a.b[0].c', 'a.b[1].d'], [1, 2])

_.zipWith

此方法类似于 _.zip，只是它接受 iteratee 来指定应如何组合分组值。使用每个组的元素调用迭代对象：(...group)。

引入版本 3.8.0

source / npm package

参数 `([arrays], [iteratee=_.identity])`

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

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

示例

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

更新日志 Release

Collection Methods 集合

_.chunk

引入版本 3.0.0

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

返回

示例

_.compact

引入版本 0.1.0

参数 _.compact(array)

返回

示例

_.concat

引入版本 4.0.0

参数 (array, [values])

返回

示例

_.difference

引入版本 0.1.0

参数 (array, [values])

返回

示例

_.differenceBy

引入版本 4.0.0

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

返回

示例

_.differenceWith

引入版本 4.0.0

参数 (array, [values], [comparator])

返回

示例

_.drop

引入版本 0.5.0

参数 (array, [n=1])

返回

示例

_.dropRight

引入版本 3.0.0

参数 (array, [n=1])

返回

示例

_.dropRightWhile

引入版本 3.0.0

参数 (array, [predicate=_.identity])

返回

示例

_.dropWhile

引入版本 3.0.0

参数 (array, [predicate=_.identity])

返回

示例

_.fill

引入版本 3.2.0

参数 (array, value, [start=0], [end=array.length])

返回

示例

_.findIndex

引入版本 1.1.0

参数 (array, [predicate=_.identity], [fromIndex=0])

返回

示例

_.findLastIndex

引入版本 2.0.0

参数 (array, [predicate=_.identity], [fromIndex=array.length-1])

返回

示例

_.flatten

引入版本 0.1.0

参数 (array)

返回

示例

_.flattenDeep

引入版本 3.0.0

参数 (array)

返回

示例

_.flattenDepth

引入版本 4.4.0

参数 (array, [depth=1])

返回

示例

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

参数 `_.compact(array)`

参数 `(array, [values])`

参数 `(array, [values])`

参数 `(array, [values], [iteratee=_.identity])`

参数 `(array, [values], [comparator])`

参数 `(array, [n=1])`

参数 `(array, [n=1])`

参数 `(array, [predicate=_.identity])`

参数 `(array, [predicate=_.identity])`

参数 `(array, value, [start=0], [end=array.length])`

参数 `(array, [predicate=_.identity], [fromIndex=0])`

参数 `(array, [predicate=_.identity], [fromIndex=array.length-1])`

参数 `(array)`

参数 `(array)`

参数 `(array, [depth=1])`

参数 `(pairs)`

参数 `(array)`

参数 `(array, value, [fromIndex=0])`

参数 `(array)`

参数 `([arrays])`

参数 `([arrays], [iteratee=_.identity])`

参数 `([arrays], [comparator])`

参数 `(array, [separator=','])`

参数 `(array)`

参数 `(array, value, [fromIndex=array.length-1])`

参数 `(array, [n=0])`

参数 `(array, [values])`