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

源代码 npm 包

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

自

3.0.0

参数

1. array (Array): 需要处理的数组
2. [size=1] (number): 每个区块的长度

返回值

(Array): 返回一个包含区块的新数组（array）。

例子

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

_.compact(array)

源代码 npm 包

创建一个移除了所有假值的数组。例如：false、null、0、""、undefined 和 NaN 都是假值。

自

0.1.0

参数

1. array (Array): 待压缩的数组

返回值

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

例子

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

_.concat(array, [values])

源代码 npm 包

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

自

4.0.0

参数

1. array (Array): 被连接的数组。
2. [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])

源代码 npm 包

创建一个具有唯一 array 值的新数组，每个值不包含在其他给定的数组中。（使用 SameValueZero 做相等比较）。结果值的顺序和引用由第一个数组确定。

**注意：** 不像 _.pullAll，这个方法会返回一个新数组。

自

0.1.0

参数

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

返回值

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

例子

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

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

源代码 npm 包

这个方法类似 _.difference ，除了它接受一个 iteratee （迭代函数），调用 array 和 values 中的每个元素以生成比较的标准。 结果值的顺序和引用由第一个数组确定。 iteratee 调用一个参数：
(value).

**注意：** 不像 _.pullAllBy，这个方法会返回一个新数组。

自

4.0.0

参数

1. array (Array): 要检查的数组。
2. [values] (...Array): 排除的值。
3. [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])

源代码 npm 包

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

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

自

4.0.0

参数

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

返回值

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

源代码 npm 包

创建一个数组切片，从 array 的开头移除 n 个元素。

自

0.5.0

参数

1. array (Array): 要查询的数组。
2. [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])

源代码 npm 包

创建一个数组切片，从 array 的末尾移除 n 个元素。

自

3.0.0

参数

1. array (Array): 要查询的数组。
2. [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])

源代码 npm 包

创建一个切片数组，去除 array 中从 predicate 返回假值开始到 array 末尾的所有元素。predicate 调用三个参数： (value, index, array)。

自

3.0.0

参数

1. array (Array): 要查询的数组。
2. [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']

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

源代码 npm 包

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

自

3.0.0

参数

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

返回值

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

源代码 npm 包

使用 value 值来填充（替换） array 中从 start 位置开始到 end 位置结束（不包含 end 位置）的所有元素。

**注意：** 这个方法会改变 array。

自

3.2.0

参数

1. array (Array): 待填充改变的数组。
2. value (*): 填充给 array 的值。
3. [start=0] (number): 开始位置（默认 0）。
4. [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]

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

源代码 npm 包

该方法类似于 _.find，不同之处在于它返回 predicate 返回 truthy 的第一个元素的索引，而不是元素本身。

自

1.1.0

参数

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

返回值

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

source npm package

此方法类似于 _.findIndex，不同之处在于它从右到左迭代 collection 的元素。

自

2.0.0

参数

1. array (Array): 要检查的数组。
2. [predicate=_.identity] (Function): 每次迭代调用的函数。
3. [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)

source npm package

将 array 扁平化为单层深度。

自

0.1.0

参数

1. array (Array)：要扁平化的数组。

返回值

(Array)：返回新的扁平化数组。

例子

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

_.flattenDeep(array)

source npm package

递归地扁平化 array。

自

3.0.0

参数

1. array (Array)：要扁平化的数组。

返回值

(Array)：返回新的扁平化数组。

例子

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

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

source npm package

递归地扁平化 array 最多 depth 次。

自

4.4.0

参数

1. array (Array)：要扁平化的数组。
2. [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)

source npm package

_.toPairs 的逆运算；此方法返回由键值对 pairs 组成的对象。

自

4.0.0

参数

1. pairs (Array)：键值对。

返回值

(Object)：返回新对象。

例子

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

_.head(array)

source npm package

获取 array 的第一个元素。

自

0.1.0

别名

_.first

参数

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

返回值

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

例子

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

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

source npm package

使用 SameValueZero 进行相等性比较，获取 value 在 array 中第一次出现的索引。如果 fromIndex 为负数，则将其用作从 array 末尾开始的偏移量。

自

0.1.0

参数

1. array (Array): 要检查的数组。
2. value (*)：要搜索的值。
3. [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)

source npm package

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

自

0.1.0

参数

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

返回值

(Array): 返回 array 的切片。

例子

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

_.intersection([arrays])

source npm package

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

自

0.1.0

参数

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

返回值

(Array)：返回包含相交值的新数组。

例子

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

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

source npm package

此方法类似于 _.intersection，不同之处在于它接受 iteratee，该参数为每个 arrays 的每个元素调用，以生成比较它们的条件。结果值的顺序和引用由第一个数组确定。迭代器使用一个参数调用
(value).

自

4.0.0

参数

1. [arrays] (...Array)：要检查的数组。
2. [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])

source npm package

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

自

4.0.0

参数

1. [arrays] (...Array)：要检查的数组。
2. [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=','])

source npm package

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

自

4.0.0

参数

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

返回值

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

例子

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

_.last(array)

source npm package

获取 array 的最后一个元素。

自

0.1.0

参数

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

返回值

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

例子

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

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

source npm package

此方法类似于 _.indexOf，不同之处在于它从右到左迭代 array 的元素。

自

0.1.0

参数

1. array (Array): 要检查的数组。
2. value (*)：要搜索的值。
3. [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])

source npm package

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

自

4.11.0

参数

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

返回值

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

例子

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

_.pull(array, [values])

source npm package

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

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

自

2.0.0

参数

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

返回值

(Array): 返回 array。

例子

var array = ['a', 'b', 'c', 'a', 'b', 'c'];
 
_.pull(array, 'a', 'c');
console.log(array);
// => ['b', 'b']

_.pullAll(array, values)

source npm package

此方法类似于 _.pull，不同之处在于它接受要删除的值数组。

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

自

4.0.0

参数

1. array (Array)：要修改的数组。
2. 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])

source npm package

此方法类似于 _.pullAll，不同之处在于它接受 iteratee，该参数为 array 和 values 的每个元素调用，以生成比较它们的条件。迭代器使用一个参数调用：(value)。

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

自

4.0.0

参数

1. array (Array)：要修改的数组。
2. values (Array)：要删除的值。
3. [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])

source npm package

此方法类似于 _.pullAll，不同之处在于它接受 comparator，该参数用于比较 array 和 values 的元素。比较器使用两个参数调用：(arrVal, othVal)。

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

自

4.6.0

参数

1. array (Array)：要修改的数组。
2. values (Array)：要删除的值。
3. [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])

source npm package

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

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

自

3.0.0

参数

1. array (Array)：要修改的数组。
2. [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])

source npm package

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

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

自

2.0.0

参数

1. array (Array)：要修改的数组。
2. [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)

source npm package

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

注意： 此方法会改变 array，并且基于 Array#reverse。

自

4.0.0

参数

1. array (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])

source npm package

创建 array 的切片，从 start 开始，到 end 结束（不包括 end）。

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

自

3.0.0

参数

1. array (Array)：要切片的数组。
2. [start=0] (number): 开始位置（默认 0）。
3. [end=array.length] (number): 结束位置（默认 array.length）。

返回值

(Array): 返回 array 的切片。

_.sortedIndex(array, value)

source npm package

使用二分搜索确定应在 array 中插入 value 的最低索引，以保持其排序顺序。

自

0.1.0

参数

1. array (Array)：要检查的已排序数组。
2. value (*)：要评估的值。

返回值

(number)：返回应在 array 中插入 value 的索引。

例子

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

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

source npm package

此方法类似于 _.sortedIndex，不同之处在于它接受 iteratee，该参数为 value 和 array 的每个元素调用，以计算它们的排序等级。迭代器使用一个参数调用：(value)。

自

4.0.0

参数

1. array (Array)：要检查的已排序数组。
2. value (*)：要评估的值。
3. [iteratee=_.identity] (Function): 每次迭代调用的迭代函数。

返回值

(number)：返回应在 array 中插入 value 的索引。

例子

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)

source npm package

此方法类似于 _.indexOf，不同之处在于它对已排序的 array 执行二分搜索。

自

4.0.0

参数

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

返回值

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

例子

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

_.sortedLastIndex(array, value)

source npm package

此方法类似于 _.sortedIndex，不同之处在于它返回应在 array 中插入 value 的最高索引，以保持其排序顺序。

自

3.0.0

参数

1. array (Array)：要检查的已排序数组。
2. value (*)：要评估的值。

返回值

(number)：返回应在 array 中插入 value 的索引。

例子

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

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

source npm package

此方法类似于 _.sortedLastIndex，不同之处在于它接受 iteratee，该参数为 value 和 array 的每个元素调用，以计算它们的排序等级。迭代器使用一个参数调用：(value)。

自

4.0.0

参数

1. array (Array)：要检查的已排序数组。
2. value (*)：要评估的值。
3. [iteratee=_.identity] (Function): 每次迭代调用的迭代函数。

返回值

(number)：返回应在 array 中插入 value 的索引。

例子

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)

source npm package

此方法类似于 _.lastIndexOf，不同之处在于它对已排序的 array 执行二分搜索。

自

4.0.0

参数

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

返回值

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

例子

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

_.sortedUniq(array)

source npm package

此方法类似于 _.uniq，不同之处在于它专为已排序数组设计和优化。

自

4.0.0

参数

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

返回值

(Array)：返回新的无重复项数组。

例子

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

_.sortedUniqBy(array, [iteratee])

source npm package

此方法类似于 _.uniqBy，不同之处在于它专为已排序的数组设计和优化。

自

4.0.0

参数

1. array (Array): 要检查的数组。
2. [iteratee] (函数): 每次迭代调用的函数。

返回值

(Array)：返回新的无重复项数组。

例子

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

_.tail(array)

源代码 npm 包

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

自

4.0.0

参数

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

返回值

(Array): 返回 array 的切片。

例子

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

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

源代码 npm 包

创建一个 array 的切片，从开头提取 n 个元素。

自

0.1.0

参数

1. array (Array): 要查询的数组。
2. [n=1] (数字): 要提取的元素数量。

返回值

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

源代码 npm 包

创建一个 array 的切片，从末尾提取 n 个元素。

自

3.0.0

参数

1. array (Array): 要查询的数组。
2. [n=1] (数字): 要提取的元素数量。

返回值

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

源代码 npm 包

创建一个 array 的切片，从末尾提取元素。提取元素直到 predicate 返回假值。该断言函数调用时将传入三个参数：(value, index, array)。

自

3.0.0

参数

1. array (Array): 要查询的数组。
2. [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])

源代码 npm 包

创建一个 array 的切片，从开头提取元素。提取元素直到 predicate 返回假值。该断言函数调用时将传入三个参数：(value, index, array)。

自

3.0.0

参数

1. array (Array): 要查询的数组。
2. [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])

源代码 npm 包

创建一个按顺序排列的唯一值数组，使用 SameValueZero 进行相等性比较，从所有给定数组中获取唯一值。

自

0.1.0

参数

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

返回值

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

例子

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

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

源代码 npm 包

此方法类似于 _.union，不同之处在于它接受 iteratee 参数，该参数针对每个 arrays 的每个元素调用，以生成计算唯一性的标准。结果值从出现该值的第一个数组中选择。迭代函数调用时将传入一个参数。
(value).

自

4.0.0

参数

1. [arrays] (...Array)：要检查的数组。
2. [iteratee=_.identity] (Function): 每次迭代调用的迭代函数。

返回值

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

例子

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

源代码 npm 包

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

自

4.0.0

参数

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

返回值

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

例子

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)

源代码 npm 包

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

自

0.1.0

参数

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

返回值

(Array)：返回新的无重复项数组。

例子

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

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

源代码 npm 包

此方法类似于 _.uniq，不同之处在于它接受 iteratee 参数，该参数针对 array 中的每个元素调用，以生成计算唯一性的标准。结果值的顺序由它们在数组中出现的顺序决定。迭代函数调用时将传入一个参数。
(value).

自

4.0.0

参数

1. array (Array): 要检查的数组。
2. [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])

源代码 npm 包

此方法类似于 _.uniq，不同之处在于它接受 comparator 参数，该参数用于比较 array 的元素。结果值的顺序由它们在数组中出现的顺序决定。比较函数调用时将传入两个参数：(arrVal, othVal)。

自

4.0.0

参数

1. array (Array): 要检查的数组。
2. [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)

源代码 npm 包

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

自

1.2.0

参数

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

源代码 npm 包

此方法类似于 _.unzip，不同之处在于它接受 iteratee 参数来指定如何组合重新分组的值。迭代函数调用时将传入每个组的元素：(...group)。

自

3.8.0

参数

1. array (数组): 要处理的分组元素的数组。
2. [iteratee=_.identity] (函数): 用于组合重新分组值的函数。

返回值

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

例子

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

_.without(array, [values])

源代码 npm 包

创建一个不包含所有给定值的数组，使用 SameValueZero 进行相等性比较。

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

自

0.1.0

参数

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

返回值

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

例子

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

_.xor([arrays])

源代码 npm 包

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

自

2.4.0

参数

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

返回值

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

例子

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

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

源代码 npm 包

此方法类似于 _.xor，不同之处在于它接受 iteratee 参数，该参数针对每个 arrays 的每个元素调用，以生成比较它们的标准。结果值的顺序由它们在数组中出现的顺序决定。迭代函数调用时将传入一个参数：(value)。

自

4.0.0

参数

1. [arrays] (...Array)：要检查的数组。
2. [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])

源代码 npm 包

此方法类似于 _.xor，不同之处在于它接受 comparator 参数，该参数用于比较 arrays 的元素。结果值的顺序由它们在数组中出现的顺序决定。比较函数调用时将传入两个参数：(arrVal, othVal)。

自

4.0.0

参数

1. [arrays] (...Array)：要检查的数组。
2. [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])

源代码 npm 包

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

自

0.1.0

参数

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

返回值

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

例子

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

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

源代码 npm 包

此方法类似于 _.fromPairs，不同之处在于它接受两个数组，一个属性标识符数组和一个相应值数组。

自

0.4.0

参数

1. [props=[]] (数组): 属性标识符。
2. [values=[]] (数组): 属性值。

返回值

(Object)：返回新对象。

例子

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

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

源代码 npm 包

此方法类似于 _.zipObject，不同之处在于它支持属性路径。

自

4.1.0

参数

1. [props=[]] (数组): 属性标识符。
2. [values=[]] (数组): 属性值。

返回值

(Object)：返回新对象。

例子

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

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

源代码 npm 包

此方法类似于 _.zip，不同之处在于它接受 iteratee 参数来指定如何组合分组的值。迭代函数调用时将传入每个组的元素：(...group)。

自

3.8.0

参数

1. [arrays] (...数组): 要处理的数组。
2. [iteratee=_.identity] (函数): 用于组合分组值的函数。

返回值

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

例子

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

_.countBy(collection, [iteratee=_.identity])

源代码 npm 包

创建一个对象，其键是通过对 collection 中的每个元素运行 iteratee 函数的结果生成的。每个键对应的值是 iteratee 函数返回该键的次数。迭代函数调用时将传入一个参数：(value)。

自

0.5.0

参数

1. collection (数组|对象): 要迭代的集合。
2. [iteratee=_.identity] (函数): 用于转换键的迭代函数。

返回值

(对象): 返回组合的聚合对象。

例子

_.countBy([6.1, 4.2, 6.3], Math.floor);
// => { '4': 1, '6': 2 }
 
// The `_.property` iteratee shorthand.
_.countBy(['one', 'two', 'three'], 'length');
// => { '3': 2, '5': 1 }

_.every(collection, [predicate=_.identity])

源代码 npm 包

检查 predicate 是否对 collection 的所有元素都返回真值。一旦 predicate 返回假值，迭代就会停止。断言函数调用时将传入三个参数：(value, index|key, collection)。

注意： 对于 空集合，此方法返回 true，因为 空集合的元素都为真。

自

0.1.0

参数

1. collection (数组|对象): 要迭代的集合。
2. [predicate=_.identity] (Function): 每次迭代调用的函数。

返回值

(布尔值): 如果所有元素都通过断言函数检查，则返回 true，否则返回 false。

例子

_.every([true, 1, null, 'yes'], Boolean);
// => false
 
var users = [
  { 'user': 'barney', 'age': 36, 'active': false },
  { 'user': 'fred',   'age': 40, 'active': false }
];
 
// The `_.matches` iteratee shorthand.
_.every(users, { 'user': 'barney', 'active': false });
// => false
 
// The `_.matchesProperty` iteratee shorthand.
_.every(users, ['active', false]);
// => true
 
// The `_.property` iteratee shorthand.
_.every(users, 'active');
// => false

_.filter(collection, [predicate=_.identity])

源代码 npm 包

迭代 collection 的元素，返回一个包含 predicate 返回真值的所有元素的数组。断言函数调用时将传入三个参数：(value, index|key, collection)。

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

自

0.1.0

参数

1. collection (数组|对象): 要迭代的集合。
2. [predicate=_.identity] (Function): 每次迭代调用的函数。

返回值

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

例子

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

_.find(collection, [predicate=_.identity], [fromIndex=0])

源代码 npm 包

迭代 collection 的元素，返回 predicate 返回真值的第一个元素。断言函数调用时将传入三个参数：(value, index|key, collection)。

自

0.1.0

参数

1. collection (数组|对象): 要检查的集合。
2. [predicate=_.identity] (Function): 每次迭代调用的函数。
3. [fromIndex=0] (number): 开始搜索的索引值。

返回值

(*): 返回匹配的元素，否则返回 undefined。

例子

var users = [
  { 'user': 'barney',  'age': 36, 'active': true },
  { 'user': 'fred',    'age': 40, 'active': false },
  { 'user': 'pebbles', 'age': 1,  'active': true }
];
 
_.find(users, function(o) { return o.age < 40; });
// => object for 'barney'
 
// The `_.matches` iteratee shorthand.
_.find(users, { 'age': 1, 'active': true });
// => object for 'pebbles'
 
// The `_.matchesProperty` iteratee shorthand.
_.find(users, ['active', false]);
// => object for 'fred'
 
// The `_.property` iteratee shorthand.
_.find(users, 'active');
// => object for 'barney'

_.findLast(collection, [predicate=_.identity], [fromIndex=collection.length-1])

源代码 npm 包

此方法类似于 _.find，不同之处在于它从右到左迭代 collection 的元素。

自

2.0.0

参数

1. collection (数组|对象): 要检查的集合。
2. [predicate=_.identity] (Function): 每次迭代调用的函数。
3. [fromIndex=collection.length-1] (数字): 开始搜索的索引。

返回值

(*): 返回匹配的元素，否则返回 undefined。

例子

_.findLast([1, 2, 3, 4], function(n) {
  return n % 2 == 1;
});
// => 3

_.flatMap(collection, [iteratee=_.identity])

源代码 npm 包

通过对 collection 中的每个元素运行 iteratee 函数并展平映射的结果，创建一个展平的值数组。迭代函数调用时将传入三个参数：(value, index|key, collection)。

自

4.0.0

参数

1. collection (数组|对象): 要迭代的集合。
2. [iteratee=_.identity] (函数): 每次迭代调用的函数。

返回值

(Array)：返回新的扁平化数组。

例子

function duplicate(n) {
  return [n, n];
}
 
_.flatMap([1, 2], duplicate);
// => [1, 1, 2, 2]

_.flatMapDeep(collection, [iteratee=_.identity])

源代码 npm 包

此方法类似于 _.flatMap，不同之处在于它递归地展平映射的结果。

自

4.7.0

参数

1. collection (数组|对象): 要迭代的集合。
2. [iteratee=_.identity] (函数): 每次迭代调用的函数。

返回值

(Array)：返回新的扁平化数组。

例子

function duplicate(n) {
  return [[[n, n]]];
}
 
_.flatMapDeep([1, 2], duplicate);
// => [1, 1, 2, 2]

_.flatMapDepth(collection, [iteratee=_.identity], [depth=1])

源代码 npm 包

此方法类似于 _.flatMap，不同之处在于它会递归地将映射结果展平最多 depth 次。

自

4.7.0

参数

1. collection (数组|对象): 要迭代的集合。
2. [iteratee=_.identity] (函数): 每次迭代调用的函数。
3. [depth=1] (number)：最大递归深度。

返回值

(Array)：返回新的扁平化数组。

例子

function duplicate(n) {
  return [[[n, n]]];
}
 
_.flatMapDepth([1, 2], duplicate, 2);
// => [[1, 1], [2, 2]]

_.forEach(collection, [iteratee=_.identity])

源代码 npm 包

遍历 collection 的元素并为每个元素调用 iteratee。使用三个参数调用迭代函数：(value, index|key, collection)。迭代函数可以通过显式返回 false 来提前退出迭代。

注意：与其他“集合”方法一样，具有“length”属性的对象将像数组一样进行迭代。为避免此行为，请使用 _.forIn 或 _.forOwn 进行对象迭代。

自

0.1.0

别名

_.each

参数

1. collection (数组|对象): 要迭代的集合。
2. [iteratee=_.identity] (函数): 每次迭代调用的函数。

返回值

(*)：返回 collection。

例子

_.forEach([1, 2], function(value) {
  console.log(value);
});
// => Logs `1` then `2`.
 
_.forEach({ 'a': 1, 'b': 2 }, function(value, key) {
  console.log(key);
});
// => Logs 'a' then 'b' (iteration order is not guaranteed).

_.forEachRight(collection, [iteratee=_.identity])

源代码 npm 包

此方法类似于 _.forEach，不同之处在于它从右到左遍历 collection 的元素。

自

2.0.0

别名

_.eachRight

参数

1. collection (数组|对象): 要迭代的集合。
2. [iteratee=_.identity] (函数): 每次迭代调用的函数。

返回值

(*)：返回 collection。

例子

_.forEachRight([1, 2], function(value) {
  console.log(value);
});
// => Logs `2` then `1`.

_.groupBy(collection, [iteratee=_.identity])

源代码 npm 包

创建一个对象，其键是由 collection 的每个元素通过 iteratee 运行的结果生成的。分组值的顺序由它们在 collection 中出现的顺序决定。每个键的对应值是一个负责生成该键的元素数组。使用一个参数调用迭代函数：(value)。

自

0.1.0

参数

1. collection (数组|对象): 要迭代的集合。
2. [iteratee=_.identity] (函数): 用于转换键的迭代函数。

返回值

(对象): 返回组合的聚合对象。

例子

_.groupBy([6.1, 4.2, 6.3], Math.floor);
// => { '4': [4.2], '6': [6.1, 6.3] }
 
// The `_.property` iteratee shorthand.
_.groupBy(['one', 'two', 'three'], 'length');
// => { '3': ['one', 'two'], '5': ['three'] }

_.includes(collection, value, [fromIndex=0])

源代码 npm 包

检查 value 是否在 collection 中。如果 collection 是字符串，则检查它是否是 value 的子字符串，否则使用 SameValueZero 进行相等比较。如果 fromIndex 为负数，则将其用作从 collection 末尾开始的偏移量。

自

0.1.0

参数

1. collection (Array|Object|string)：要检查的集合。
2. value (*)：要搜索的值。
3. [fromIndex=0] (number): 开始搜索的索引值。

返回值

(boolean)：如果找到 value，则返回 true，否则返回 false。

例子

_.includes([1, 2, 3], 1);
// => true
 
_.includes([1, 2, 3], 1, 2);
// => false
 
_.includes({ 'a': 1, 'b': 2 }, 1);
// => true
 
_.includes('abcd', 'bc');
// => true

_.invokeMap(collection, path, [args])

源代码 npm 包

调用 collection 中每个元素的 path 处的方法，返回一个包含每个已调用方法的结果的数组。所有其他参数都将提供给每个已调用的方法。如果 path 是函数，则将为 collection 中的每个元素调用它，并将 this 绑定到该元素。

自

4.0.0

参数

1. collection (数组|对象): 要迭代的集合。
2. path (Array|Function|string)：要调用的方法的路径或每次迭代调用的函数。
3. [args] (...*)：用于调用每个方法的参数。

返回值

(Array)：返回结果数组。

例子

_.invokeMap([[5, 1, 7], [3, 2, 1]], 'sort');
// => [[1, 5, 7], [1, 2, 3]]
 
_.invokeMap([123, 456], String.prototype.split, '');
// => [['1', '2', '3'], ['4', '5', '6']]

_.keyBy(collection, [iteratee=_.identity])

源代码 npm 包

创建一个对象，其键是由 collection 的每个元素通过 iteratee 运行的结果生成的。每个键的对应值是负责生成该键的最后一个元素。使用一个参数调用迭代函数：(value)。

自

4.0.0

参数

1. collection (数组|对象): 要迭代的集合。
2. [iteratee=_.identity] (函数): 用于转换键的迭代函数。

返回值

(对象): 返回组合的聚合对象。

例子

var array = [
  { 'dir': 'left', 'code': 97 },
  { 'dir': 'right', 'code': 100 }
];
 
_.keyBy(array, function(o) {
  return String.fromCharCode(o.code);
});
// => { 'a': { 'dir': 'left', 'code': 97 }, 'd': { 'dir': 'right', 'code': 100 } }
 
_.keyBy(array, 'dir');
// => { 'left': { 'dir': 'left', 'code': 97 }, 'right': { 'dir': 'right', 'code': 100 } }

_.map(collection, [iteratee=_.identity])

源代码 npm 包

通过运行 collection 中的每个元素来创建一个值数组 iteratee。使用三个参数调用迭代函数
(value, index|key, collection).

许多 lodash 方法都被保护为迭代函数，用于诸如 _.every、_.filter、_.map、_.mapValues、_.reject 和 _.some 之类的方法。

受保护的方法有
ary、chunk、curry、curryRight、drop、dropRight、every、fill、invert、parseInt、random、range、rangeRight、repeat、sampleSize、slice、some、sortBy、split、take、takeRight、template、trim、trimEnd、trimStart 和 words

自

0.1.0

参数

1. collection (数组|对象): 要迭代的集合。
2. [iteratee=_.identity] (函数): 每次迭代调用的函数。

返回值

(Array)：返回新的映射数组。

例子

function square(n) {
  return n * n;
}
 
_.map([4, 8], square);
// => [16, 64]
 
_.map({ 'a': 4, 'b': 8 }, square);
// => [16, 64] (iteration order is not guaranteed)
 
var users = [
  { 'user': 'barney' },
  { 'user': 'fred' }
];
 
// The `_.property` iteratee shorthand.
_.map(users, 'user');
// => ['barney', 'fred']

_.orderBy(collection, [iteratees=[_.identity]], [orders])

源代码 npm 包

此方法类似于 _.sortBy，不同之处在于它允许指定要排序的迭代函数的排序顺序。如果未指定 orders，则所有值都按升序排序。否则，为相应值的降序或升序排序顺序指定“desc”或“asc”顺序。

自

4.0.0

参数

1. collection (数组|对象): 要迭代的集合。
2. [iteratees=[_.identity]] (Array[]|Function[]|Object[]|string[])：要排序的迭代函数。
3. [orders] (string[])：iteratees 的排序顺序。

返回值

(Array)：返回新的排序数组。

例子

var users = [
  { 'user': 'fred',   'age': 48 },
  { 'user': 'barney', 'age': 34 },
  { 'user': 'fred',   'age': 40 },
  { 'user': 'barney', 'age': 36 }
];
 
// Sort by `user` in ascending order and by `age` in descending order.
_.orderBy(users, ['user', 'age'], ['asc', 'desc']);
// => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 40]]

_.partition(collection, [predicate=_.identity])

源代码 npm 包

创建一个元素数组，该数组分为两组，第一组包含 predicate 返回真值的元素，第二组包含 predicate 返回假值的元素。使用一个参数调用谓词函数：(value)。

自

3.0.0

参数

1. collection (数组|对象): 要迭代的集合。
2. [predicate=_.identity] (Function): 每次迭代调用的函数。

返回值

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

例子

var users = [
  { 'user': 'barney',  'age': 36, 'active': false },
  { 'user': 'fred',    'age': 40, 'active': true },
  { 'user': 'pebbles', 'age': 1,  'active': false }
];
 
_.partition(users, function(o) { return o.active; });
// => objects for [['fred'], ['barney', 'pebbles']]
 
// The `_.matches` iteratee shorthand.
_.partition(users, { 'age': 1, 'active': false });
// => objects for [['pebbles'], ['barney', 'fred']]
 
// The `_.matchesProperty` iteratee shorthand.
_.partition(users, ['active', false]);
// => objects for [['barney', 'pebbles'], ['fred']]
 
// The `_.property` iteratee shorthand.
_.partition(users, 'active');
// => objects for [['fred'], ['barney', 'pebbles']]

_.reduce(collection, [iteratee=_.identity], [accumulator])

源代码 npm 包

将 collection 简化为一个值，该值是通过 iteratee 运行 collection 中的每个元素的累积结果，其中每次连续调用都提供前一次调用的返回值。如果未提供 accumulator，则使用 collection 的第一个元素作为初始值。使用四个参数调用迭代函数
(accumulator, value, index|key, collection).

许多 lodash 方法都被保护为迭代函数，用于诸如 _.reduce、_.reduceRight 和 _.transform 之类的方法。

受保护的方法有
assign、defaults、defaultsDeep、includes、merge、orderBy 和 sortBy

自

0.1.0

参数

1. collection (数组|对象): 要迭代的集合。
2. [iteratee=_.identity] (函数): 每次迭代调用的函数。
3. [accumulator] (*)：初始值。

返回值

(*)：返回累积值。

例子

_.reduce([1, 2], function(sum, n) {
  return sum + n;
}, 0);
// => 3
 
_.reduce({ 'a': 1, 'b': 2, 'c': 1 }, function(result, value, key) {
  (result[value] || (result[value] = [])).push(key);
  return result;
}, {});
// => { '1': ['a', 'c'], '2': ['b'] } (iteration order is not guaranteed)

_.reduceRight(collection, [iteratee=_.identity], [accumulator])

源代码 npm 包

此方法类似于 _.reduce，不同之处在于它从右到左遍历 collection 的元素。

自

0.1.0

参数

1. collection (数组|对象): 要迭代的集合。
2. [iteratee=_.identity] (函数): 每次迭代调用的函数。
3. [accumulator] (*)：初始值。

返回值

(*)：返回累积值。

例子

var array = [[0, 1], [2, 3], [4, 5]];
 
_.reduceRight(array, function(flattened, other) {
  return flattened.concat(other);
}, []);
// => [4, 5, 2, 3, 0, 1]

_.reject(collection, [predicate=_.identity])

源代码 npm 包

与 _.filter 相反；此方法返回 collection 中 predicate 不返回真值的元素。

自

0.1.0

参数

1. collection (数组|对象): 要迭代的集合。
2. [predicate=_.identity] (Function): 每次迭代调用的函数。

返回值

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

例子

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

_.sample(collection)

源代码 npm 包

从 collection 中获取一个随机元素。

自

2.0.0

参数

1. collection (Array|Object)：要从中采样的集合。

返回值

(*)：返回随机元素。

例子

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

_.sampleSize(collection, [n=1])

源代码 npm 包

从 collection 中获取 n 个唯一键处的随机元素，最多获取 collection 的大小。

自

4.0.0

参数

1. collection (Array|Object)：要从中采样的集合。
2. [n=1] (number)：要采样的元素数量。

返回值

(Array)：返回随机元素。

例子

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

_.shuffle(collection)

源代码 npm 包

使用 Fisher-Yates 洗牌算法 的版本创建一个打乱值的数组。

自

0.1.0

参数

1. collection (Array|Object)：要打乱的集合。

返回值

(Array)：返回新的打乱数组。

例子

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

_.size(collection)

源代码 npm 包

通过返回类数组值的长度或对象自身可枚举字符串键属性的数量来获取 collection 的大小。

自

0.1.0

参数

1. collection (Array|Object|string)：要检查的集合。

返回值

(number)：返回集合大小。

例子

_.size([1, 2, 3]);
// => 3
 
_.size({ 'a': 1, 'b': 2 });
// => 2
 
_.size('pebbles');
// => 7

_.some(collection, [predicate=_.identity])

源代码 npm 包

检查 predicate 是否对 collection 的任何元素返回真值。一旦 predicate 返回真值，迭代就会停止。使用三个参数调用谓词函数：(value, index|key, collection)。

自

0.1.0

参数

1. collection (数组|对象): 要迭代的集合。
2. [predicate=_.identity] (Function): 每次迭代调用的函数。

返回值

(boolean)：如果任何元素通过谓词检查，则返回 true，否则返回 false。

例子

_.some([null, 0, 'yes', false], Boolean);
// => true
 
var users = [
  { 'user': 'barney', 'active': true },
  { 'user': 'fred',   'active': false }
];
 
// The `_.matches` iteratee shorthand.
_.some(users, { 'user': 'barney', 'active': false });
// => false
 
// The `_.matchesProperty` iteratee shorthand.
_.some(users, ['active', false]);
// => true
 
// The `_.property` iteratee shorthand.
_.some(users, 'active');
// => true

_.sortBy(collection, [iteratees=[_.identity]])

源代码 npm 包

创建一个元素数组，该数组按在集合中运行每个元素通过每个迭代函数的结果按升序排序。此方法执行稳定排序，也就是说，它保留相等元素的原始排序顺序。使用一个参数调用迭代函数：(value)。

自

0.1.0

参数

1. collection (数组|对象): 要迭代的集合。
2. [iteratees=[_.identity]] (...(Function|Function[]))：要排序的迭代函数。

返回值

(Array)：返回新的排序数组。

例子

var users = [
  { 'user': 'fred',   'age': 48 },
  { 'user': 'barney', 'age': 36 },
  { 'user': 'fred',   'age': 40 },
  { 'user': 'barney', 'age': 34 }
];
 
_.sortBy(users, [function(o) { return o.user; }]);
// => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 40]]
 
_.sortBy(users, ['user', 'age']);
// => objects for [['barney', 34], ['barney', 36], ['fred', 40], ['fred', 48]]

_.now()

源代码 npm 包

获取自 Unix 纪元（1970 年 1 月 1 日 00:00:00 UTC）以来经过的毫秒数的时间戳。

自

2.4.0

返回值

(number)：返回时间戳。

例子

_.defer(function(stamp) {
  console.log(_.now() - stamp);
}, _.now());
// => Logs the number of milliseconds it took for the deferred invocation.

_.after(n, func)

源代码 npm 包

与 _.before 相反；此方法创建一个函数，该函数在其被调用 n 次或更多次后调用 func。

自

0.1.0

参数

1. n (number)：在调用 func 之前的调用次数。
2. func (Function)：要限制的函数。

返回值

(Function)：返回新的受限函数。

例子

var saves = ['profile', 'settings'];
 
var done = _.after(saves.length, function() {
  console.log('done saving!');
});
 
_.forEach(saves, function(type) {
  asyncSave({ 'type': type, 'complete': done });
});
// => Logs 'done saving!' after the two async saves have completed.

_.ary(func, [n=func.length])

源代码 npm 包

创建一个函数，该函数调用 func，最多使用 n 个参数，忽略任何其他参数。

自

3.0.0

参数

1. func (Function)：要限制参数的函数。
2. [n=func.length] (number)：参数数量上限。

返回值

(Function)：返回新的受限函数。

例子

_.map(['6', '8', '10'], _.ary(parseInt, 1));
// => [6, 8, 10]

_.before(n, func)

源代码 npm 包

创建一个函数，该函数使用创建函数的 this 绑定和参数调用 func，而它被调用的次数小于 n 次。对创建函数的后续调用将返回最后一次 func 调用的结果。

自

3.0.0

参数

1. n (number)：不再调用 func 的调用次数。
2. func (Function)：要限制的函数。

返回值

(Function)：返回新的受限函数。

例子

jQuery(element).on('click', _.before(5, addContactToList));
// => Allows adding up to 4 contacts to the list.

_.bind(func, thisArg, [partials])

源代码 npm 包

创建一个函数，该函数使用 thisArg 的 this 绑定和预置在其接收的参数之前的 partials 调用 func。

_.bind.placeholder 值（在整体构建中默认为 _）可以用作部分应用参数的占位符。

注意：与原生 Function#bind 不同，此方法不会设置绑定函数的“length”属性。

自

0.1.0

参数

1. func (Function)：要绑定的函数。
2. thisArg (*)：func 的 this 绑定。
3. [partials] (...*)：要部分应用的参数。

返回值

（函数）：返回新的绑定函数。

例子

function greet(greeting, punctuation) {
  return greeting + ' ' + this.user + punctuation;
}
 
var object = { 'user': 'fred' };
 
var bound = _.bind(greet, object, 'hi');
bound('!');
// => 'hi fred!'
 
// Bound with placeholders.
var bound = _.bind(greet, object, _, '!');
bound('hi');
// => 'hi fred!'

_.bindKey(object, key, [partials])

源代码 npm 包

创建一个函数，该函数使用预先添加到其接收到的参数中的 partials 调用 object[key] 处的方法。

此方法与 _.bind 的不同之处在于，绑定函数可以引用可能重新定义或尚不存在的方法。有关更多详细信息，请参阅 Peter Michaux 的文章。

_.bindKey.placeholder 值（在单体构建中默认为 _）可用作部分应用参数的占位符。

自

0.10.0

参数

1. object （对象）：要调用其方法的对象。
2. key （字符串）：方法的键。
3. [partials] (...*)：要部分应用的参数。

返回值

（函数）：返回新的绑定函数。

例子

var object = {
  'user': 'fred',
  'greet': function(greeting, punctuation) {
    return greeting + ' ' + this.user + punctuation;
  }
};
 
var bound = _.bindKey(object, 'greet', 'hi');
bound('!');
// => 'hi fred!'
 
object.greet = function(greeting, punctuation) {
  return greeting + 'ya ' + this.user + punctuation;
};
 
bound('!');
// => 'hiya fred!'
 
// Bound with placeholders.
var bound = _.bindKey(object, 'greet', _, '!');
bound('hi');
// => 'hiya fred!'

_.curry(func, [arity=func.length])

源代码 npm 包

创建一个函数，该函数接受 func 的参数，如果至少提供了 arity 个参数，则调用 func 并返回其结果，否则返回一个接受剩余 func 参数的函数，依此类推。如果 func.length 不够，则可以指定 func 的元数。

_.curry.placeholder 值（在单体构建中默认为 _）可用作已提供参数的占位符。

**注意：** 此方法不会设置柯里化函数的 “length” 属性。

自

2.0.0

参数

1. func （函数）：要进行柯里化的函数。
2. [arity=func.length] （数字）：func 的元数。

返回值

（函数）：返回新的柯里化函数。

例子

var abc = function(a, b, c) {
  return [a, b, c];
};
 
var curried = _.curry(abc);
 
curried(1)(2)(3);
// => [1, 2, 3]
 
curried(1, 2)(3);
// => [1, 2, 3]
 
curried(1, 2, 3);
// => [1, 2, 3]
 
// Curried with placeholders.
curried(1)(_, 3)(2);
// => [1, 3, 2]

_.curryRight(func, [arity=func.length])

源代码 npm 包

此方法类似于 _.curry，不同之处在于参数以 _.partialRight 而不是 _.partial 的方式应用于 func。

_.curryRight.placeholder 值（在单体构建中默认为 _）可用作已提供参数的占位符。

**注意：** 此方法不会设置柯里化函数的 “length” 属性。

自

3.0.0

参数

1. func （函数）：要进行柯里化的函数。
2. [arity=func.length] （数字）：func 的元数。

返回值

（函数）：返回新的柯里化函数。

例子

var abc = function(a, b, c) {
  return [a, b, c];
};
 
var curried = _.curryRight(abc);
 
curried(3)(2)(1);
// => [1, 2, 3]
 
curried(2, 3)(1);
// => [1, 2, 3]
 
curried(1, 2, 3);
// => [1, 2, 3]
 
// Curried with placeholders.
curried(3)(1, _)(2);
// => [1, 2, 3]

_.debounce(func, [wait=0], [options={}])

源代码 npm 包

创建一个防抖函数，该函数将延迟调用 func，直到自上次调用防抖函数以来经过了 wait 毫秒。防抖函数带有一个 cancel 方法，用于取消延迟的 func 调用，以及一个 flush 方法，用于立即调用它们。提供 options 以指示是否应在 wait 超时的前沿和/或后沿调用 func。使用提供给防抖函数的最后一个参数调用 func。对防抖函数的后续调用将返回最后一次 func 调用的结果。

**注意：** 如果 leading 和 trailing 选项均为 true，则仅当在 wait 超时期间多次调用防抖函数时，才会在超时的后沿调用 func。

如果 wait 为 0 且 leading 为 false，则 func 调用将推迟到下一个计时器周期，类似于超时时间为 0 的 setTimeout。

有关 _.debounce 和 _.throttle 之间差异的详细信息，请参阅 David Corbacho 的文章。

自

0.1.0

参数

1. func （函数）：要进行防抖的函数。
2. [wait=0] （数字）：延迟的毫秒数。
3. [options={}] （对象）：选项对象。
4. [options.leading=false] （布尔值）：指定在超时的前沿调用。
5. [options.maxWait] （数字）：允许延迟 func 调用之前，允许的最长时间。
6. [options.trailing=true] （布尔值）：指定在超时的后沿调用。

返回值

（函数）：返回新的防抖函数。

例子

// Avoid costly calculations while the window size is in flux.
jQuery(window).on('resize', _.debounce(calculateLayout, 150));
 
// Invoke `sendMail` when clicked, debouncing subsequent calls.
jQuery(element).on('click', _.debounce(sendMail, 300, {
  'leading': true,
  'trailing': false
}));
 
// Ensure `batchLog` is invoked once after 1 second of debounced calls.
var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 });
var source = new EventSource('/stream');
jQuery(source).on('message', debounced);
 
// Cancel the trailing debounced invocation.
jQuery(window).on('popstate', debounced.cancel);

_.defer(func, [args])

源代码 npm 包

推迟调用 func，直到当前调用堆栈已清除。调用 func 时，将向其提供任何其他参数。

自

0.1.0

参数

1. func （函数）：要推迟的函数。
2. [args] （...*）：用于调用 func 的参数。

返回值

（数字）：返回计时器 ID。

例子

_.defer(function(text) {
  console.log(text);
}, 'deferred');
// => Logs 'deferred' after one millisecond.

_.delay(func, wait, [args])

源代码 npm 包

在 wait 毫秒后调用 func。调用 func 时，将向其提供任何其他参数。

自

0.1.0

参数

1. func （函数）：要延迟的函数。
2. wait （数字）：延迟调用的毫秒数。
3. [args] （...*）：用于调用 func 的参数。

返回值

（数字）：返回计时器 ID。

例子

_.delay(function(text) {
  console.log(text);
}, 1000, 'later');
// => Logs 'later' after one second.

_.flip(func)

源代码 npm 包

创建一个以相反顺序调用 func 的参数的函数。

自

4.0.0

参数

1. func （函数）：要反转其参数的函数。

返回值

（函数）：返回新的反转函数。

例子

var flipped = _.flip(function() {
  return _.toArray(arguments);
});
 
flipped('a', 'b', 'c', 'd');
// => ['d', 'c', 'b', 'a']

_.memoize(func, [resolver])

源代码 npm 包

创建一个记忆 func 结果的函数。如果提供了 resolver，它将根据提供给记忆函数的参数确定用于存储结果的缓存键。默认情况下，提供给记忆函数的第一个参数用作映射缓存键。使用记忆函数的 this 绑定调用 func。

**注意：** 缓存作为记忆函数上的 cache 属性公开。可以通过将 _.memoize.Cache 构造函数替换为其实例实现 Map 方法接口（clear、delete、get、has 和 set）的构造函数来自定义其创建。

自

0.1.0

参数

1. func （函数）：要记忆其输出的函数。
2. [resolver] （函数）：用于解析缓存键的函数。

返回值

（函数）：返回新的记忆函数。

例子

var object = { 'a': 1, 'b': 2 };
var other = { 'c': 3, 'd': 4 };
 
var values = _.memoize(_.values);
values(object);
// => [1, 2]
 
values(other);
// => [3, 4]
 
object.a = 2;
values(object);
// => [1, 2]
 
// Modify the result cache.
values.cache.set(object, ['a', 'b']);
values(object);
// => ['a', 'b']
 
// Replace `_.memoize.Cache`.
_.memoize.Cache = WeakMap;

_.negate(predicate)

源代码 npm 包

创建一个否定谓词 func 结果的函数。使用创建函数的 this 绑定和参数调用 func 谓词。

自

3.0.0

参数

1. predicate （函数）：要否定的谓词。

返回值

（函数）：返回新的否定函数。

例子

function isEven(n) {
  return n % 2 == 0;
}
 
_.filter([1, 2, 3, 4, 5, 6], _.negate(isEven));
// => [1, 3, 5]

_.once(func)

源代码 npm 包

创建一个仅限于调用 func 一次的函数。对该函数的重复调用将返回第一次调用的值。使用创建函数的 this 绑定和参数调用 func。

自

0.1.0

参数

1. func (Function)：要限制的函数。

返回值

(Function)：返回新的受限函数。

例子

var initialize = _.once(createApplication);
initialize();
initialize();
// => `createApplication` is invoked once

_.overArgs(func, [transforms=[_.identity]])

源代码 npm 包

创建一个使用其转换后的参数调用 func 的函数。

自

4.0.0

参数

1. func （函数）：要包装的函数。
2. [transforms=[_.identity]] (...(Function|Function[]))：参数转换。

返回值

（函数）：返回新函数。

例子

function doubled(n) {
  return n * 2;
}
 
function square(n) {
  return n * n;
}
 
var func = _.overArgs(function(x, y) {
  return [x, y];
}, [square, doubled]);
 
func(9, 3);
// => [81, 6]
 
func(10, 5);
// => [100, 10]

_.partial(func, [partials])

源代码 npm 包

创建一个函数，该函数使用预先添加到其接收到的参数中的 partials 调用 func。此方法类似于 _.bind，不同之处在于它**不会**更改 this 绑定。

_.partial.placeholder 值（在单体构建中默认为 _）可用作部分应用参数的占位符。

**注意：** 此方法不会设置部分应用函数的 “length” 属性。

自

0.2.0

参数

1. func （函数）：要部分应用参数的函数。
2. [partials] (...*)：要部分应用的参数。

返回值

（函数）：返回新的部分应用函数。

例子

function greet(greeting, name) {
  return greeting + ' ' + name;
}
 
var sayHelloTo = _.partial(greet, 'hello');
sayHelloTo('fred');
// => 'hello fred'
 
// Partially applied with placeholders.
var greetFred = _.partial(greet, _, 'fred');
greetFred('hi');
// => 'hi fred'

_.partialRight(func, [partials])

源代码 npm 包

此方法类似于 _.partial，不同之处在于部分应用的参数会附加到其接收到的参数中。

_.partialRight.placeholder 值（在单体构建中默认为 _）可用作部分应用参数的占位符。

**注意：** 此方法不会设置部分应用函数的 “length” 属性。

自

1.0.0

参数

1. func （函数）：要部分应用参数的函数。
2. [partials] (...*)：要部分应用的参数。

返回值

（函数）：返回新的部分应用函数。

例子

function greet(greeting, name) {
  return greeting + ' ' + name;
}
 
var greetFred = _.partialRight(greet, 'fred');
greetFred('hi');
// => 'hi fred'
 
// Partially applied with placeholders.
var sayHelloTo = _.partialRight(greet, 'hello', _);
sayHelloTo('fred');
// => 'hello fred'

_.rearg(func, indexes)

源代码 npm 包

创建一个函数，该函数使用根据指定的 indexes 排列的参数调用 func，其中第一个索引处的参数值作为第一个参数提供，第二个索引处的参数值作为第二个参数提供，依此类推。

自

3.0.0

参数

1. func （函数）：要重新排列其参数的函数。
2. indexes (...(number|number[]))：排列的参数索引。

返回值

（函数）：返回新函数。

例子

var rearged = _.rearg(function(a, b, c) {
  return [a, b, c];
}, [2, 0, 1]);
 
rearged('b', 'c', 'a')
// => ['a', 'b', 'c']

_.rest(func, [start=func.length-1])

源代码 npm 包

创建一个函数，该函数使用创建函数的 this 绑定调用 func，并将 start 及之后的参数作为数组提供。

**注意：** 此方法基于 剩余参数。

自

4.0.0

参数

1. func （函数）：要应用剩余参数的函数。
2. [start=func.length-1] （数字）：剩余参数的起始位置。

返回值

（函数）：返回新函数。

例子

var say = _.rest(function(what, names) {
  return what + ' ' + _.initial(names).join(', ') +
    (_.size(names) > 1 ? ', & ' : '') + _.last(names);
});
 
say('hello', 'fred', 'barney', 'pebbles');
// => 'hello fred, barney, & pebbles'

_.spread(func, [start=0])

源代码 npm 包

创建一个函数，该函数使用创建函数的 this 绑定和参数数组调用 func，非常类似于 Function#apply。

**注意：** 此方法基于 展开运算符。

自

3.2.0

参数

1. func （函数）：要展开参数的函数。
2. [start=0] （数字）：展开的起始位置。

返回值

（函数）：返回新函数。

例子

var say = _.spread(function(who, what) {
  return who + ' says ' + what;
});
 
say(['fred', 'hello']);
// => 'fred says hello'
 
var numbers = Promise.all([
  Promise.resolve(40),
  Promise.resolve(36)
]);
 
numbers.then(_.spread(function(x, y) {
  return x + y;
}));
// => a Promise of 76

_.throttle(func, [wait=0], [options={}])

源代码 npm 包

创建一个节流函数，该函数每 wait 毫秒最多调用 func 一次。节流函数带有一个 cancel 方法，用于取消延迟的 func 调用，以及一个 flush 方法，用于立即调用它们。提供 options 以指示是否应在 wait 超时的前沿和/或后沿调用 func。使用提供给节流函数的最后一个参数调用 func。对节流函数的后续调用将返回最后一次 func 调用的结果。

**注意：** 如果 leading 和 trailing 选项均为 true，则仅当在 wait 超时期间多次调用节流函数时，才会在超时的后沿调用 func。

如果 wait 为 0 且 leading 为 false，则 func 调用将推迟到下一个计时器周期，类似于超时时间为 0 的 setTimeout。

有关 _.throttle 和 _.debounce 之间差异的详细信息，请参阅 David Corbacho 的文章。

自

0.1.0

参数

1. func （函数）：要进行节流的函数。
2. [wait=0] （数字）：将调用节流到的毫秒数。
3. [options={}] （对象）：选项对象。
4. [options.leading=true] （布尔值）：指定在超时的前沿调用。
5. [options.trailing=true] （布尔值）：指定在超时的后沿调用。

返回值

（函数）：返回新的节流函数。

例子

// Avoid excessively updating the position while scrolling.
jQuery(window).on('scroll', _.throttle(updatePosition, 100));
 
// Invoke `renewToken` when the click event is fired, but not more than once every 5 minutes.
var throttled = _.throttle(renewToken, 300000, { 'trailing': false });
jQuery(element).on('click', throttled);
 
// Cancel the trailing throttled invocation.
jQuery(window).on('popstate', throttled.cancel);

_.unary(func)

源代码 npm 包

创建一个最多接受一个参数的函数，忽略任何其他参数。

自

4.0.0

参数

1. func (Function)：要限制参数的函数。

返回值

(Function)：返回新的受限函数。

例子

_.map(['6', '8', '10'], _.unary(parseInt));
// => [6, 8, 10]

_.wrap(value, [wrapper=identity])

源代码 npm 包

创建一个函数，将 value 作为第一个参数提供给 wrapper。提供给该函数的任何其他参数都将附加到提供给 wrapper 的参数中。使用创建函数的 this 绑定调用包装器。

自

0.1.0

参数

1. value (*): 要包装的值。
2. [wrapper=identity] (函数): 包装函数。

返回值

（函数）：返回新函数。

例子

var p = _.wrap(_.escape, function(func, text) {
  return '<p>' + func(text) + '</p>';
});
 
p('fred, barney, & pebbles');
// => '<p>fred, barney, &amp; pebbles</p>'