Array (数组)

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

引入版本 3.0.0

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

参数

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

(Array): 返回一个包含拆分区块的新数组。

示例

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

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

_.compact(array)

引入版本 0.1.0

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

参数

array (Array): 待处理的数组。

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

示例

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

_.concat(array, [values])

引入版本 4.0.0

创建一个新数组，将 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]

_.difference(array, [values])

引入版本 0.1.0

创建一个新数组，这个数组中的元素存在于 array 中，但不存在于其他给定数组（values）中。（即求数组的差集）。

该方法使用 SameValueZero 做相等比较。结果元素的顺序和引用由第一个数组决定。

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

参数

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

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

示例

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

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

引入版本 4.0.0

这个方法类似 _.difference，区别在于它接受一个 iteratee（迭代函数），调用该函数处理 array 和 values 中的每个元素，以生成比较的标准。结果值的顺序和引用由第一个数组决定。

iteratee 调用时会传入一个参数：(value)。

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

参数

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

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

示例

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

// 使用 `_.property` 的迭代器简写
_.differenceBy([{ x: 2 }, { x: 1 }], [{ x: 1 }], "x");
// => [{ 'x': 2 }]

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

引入版本 4.0.0

这个方法类似 _.difference，区别在于它接受一个 comparator（比较器），调用该函数来比较 array 和 values 中的元素。结果值的顺序和引用由第一个数组决定。

comparator 调用时会传入两个参数：(arrVal, othVal)。

注意： 不同于 _.pullAllWith，这个方法会返回一个新数组。

参数

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

引入版本 0.5.0

创建一个切片数组，去除 array 前面的 n 个元素。（即从头开始丢弃 n 个元素）。

参数

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

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

引入版本 3.0.0

创建一个切片数组，去除 array 尾部的 n 个元素。（即从末尾开始丢弃 n 个元素）。

参数

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

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

引入版本 3.0.0

创建一个切片数组，从 array 的尾部开始丢弃元素。元素会一直被丢弃，直到 predicate 返回假值（falsey）。

predicate 调用时会传入三个参数：(value, index, array)。

参数

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

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

// 使用 `_.matches` 的迭代器简写
_.dropRightWhile(users, { user: "pebbles", active: false });
// => objects for ['barney', 'fred']

// 使用 `_.matchesProperty` 的迭代器简写
_.dropRightWhile(users, ["active", false]);
// => objects for ['barney']

// 使用 `_.property` 的迭代器简写
_.dropRightWhile(users, "active");
// => objects for ['barney', 'fred', 'pebbles']

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

引入版本 3.0.0

创建一个切片数组，从 array 的开头开始丢弃元素。元素会一直被丢弃，直到 predicate 返回假值（falsey）。

predicate 调用时会传入三个参数：(value, index, array)。

参数

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

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

// 使用 `_.matches` 的迭代器简写
_.dropWhile(users, { user: "barney", active: false });
// => objects for ['fred', 'pebbles']

// 使用 `_.matchesProperty` 的迭代器简写
_.dropWhile(users, ["active", false]);
// => objects for ['pebbles']

// 使用 `_.property` 的迭代器简写
_.dropWhile(users, "active");
// => objects for ['barney', 'fred', 'pebbles']

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

引入版本 3.2.0

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

注意： 这个方法会改变原数组（mutate）。

参数

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

(Array): 返回 array。

示例

var array = [1, 2, 3];

_.fill(array, "a");
console.log(array);
// => ['a', 'a', 'a']

_.fill(Array(3), 2);
// => [2, 2, 2]

_.fill([4, 6, 8, 10], "*", 1, 3);
// => [4, '*', '*', 10]

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

引入版本 1.1.0

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

参数

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

// 使用 `_.matches` 的迭代器简写
_.findIndex(users, { user: "fred", active: false });
// => 1

// 使用 `_.matchesProperty` 的迭代器简写
_.findIndex(users, ["active", false]);
// => 0

// 使用 `_.property` 的迭代器简写
_.findIndex(users, "active");
// => 2

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

引入版本 2.0.0

该方法类似 _.findIndex，区别在于它是从右到左（即反向）遍历集合中的元素。

参数

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

// 使用 `_.matches` 的迭代器简写
_.findLastIndex(users, { user: "barney", active: true });
// => 0

// 使用 `_.matchesProperty` 的迭代器简写
_.findLastIndex(users, ["active", false]);
// => 2

// 使用 `_.property` 的迭代器简写
_.findLastIndex(users, "active");
// => 0

_.flatten(array)

引入版本 0.1.0

将数组 array 减少一级嵌套深度。（即只扁平化一层）。

参数

array (Array): 需要扁平化的数组。

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

示例

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

_.flattenDeep(array)

引入版本 3.0.0

将数组递归地扁平化。（即将数组的所有嵌套层级全部展开）。

参数

array (Array): 需要扁平化的数组。

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

示例

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

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

引入版本 4.4.0

根据指定的 depth（深度）递归地扁平化数组。

参数

array (Array): 需要扁平化的数组。
[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)

引入版本 4.0.0

_.toPairs 的反向操作；此方法返回一个由键值对 pairs 构成的对象。

参数

pairs (Array): 键值对数组。

(Object): 返回新对象。

示例

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

_.head(array)

引入版本 0.1.0

获取数组的第一个元素。

别名： _.first

参数

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

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

示例

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

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

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

引入版本 0.1.0

获取 value 在数组 array 中首次出现的位置（索引），使用 SameValueZero 进行相等比较。如果 fromIndex 为负值，则表示从数组结尾开始的偏移量。

参数

array (Array): 待检查的数组。
value (*): 要搜索的值。
[fromIndex=0] (number): 开始搜索的索引位置。

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

示例

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

// 从 `fromIndex` 位置开始搜索
_.indexOf([1, 2, 1, 2], 2, 2);
// => 3

_.initial(array)

引入版本 0.1.0

获取数组中除了最后一个元素之外的所有元素。

参数

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

(Array): 返回数组的切片。

示例

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

_.intersection([arrays])

引入版本 0.1.0

创建一个新数组，包含所有给定数组共有的唯一值（即求数组的交集）。

该方法使用 SameValueZero 进行相等比较。结果值的顺序和引用由第一个数组决定。

参数

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

(Array): 返回包含交集元素的新数组。

示例

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

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

引入版本 4.0.0

这个方法类似 _.intersection，区别在于它接受一个 iteratee（迭代函数），调用该函数处理每一个数组中的每个元素，以生成比较的标准。结果值的顺序和引用由第一个数组决定。

iteratee 调用时会传入一个参数：(value)。

参数

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

(Array): 返回包含交集元素的新数组。

示例

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

// 使用 `_.property` 的迭代器简写
_.intersectionBy([{ x: 1 }], [{ x: 2 }, { x: 1 }], "x");
// => [{ 'x': 1 }]

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

引入版本 4.0.0

这个方法类似 _.intersection，区别在于它接受一个 comparator（比较器），调用该函数来比较 arrays 中的元素。结果值的顺序和引用由第一个数组决定。

comparator 调用时会传入两个参数：(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 },
];

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

_.join(array, [separator=','])

引入版本 4.0.0

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

参数

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

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

示例

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

_.last(array)

引入版本 0.1.0

获取数组的最后一个元素。

参数

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

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

示例

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

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

引入版本 0.1.0

这个方法类似 _.indexOf，区别在于它是从右到左（即反向）遍历数组元素。

参数

array (Array): 待检查的数组。
value (*): 要搜索的值。
[fromIndex=array.length-1] (number): 开始搜索的索引位置。

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

示例

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

// 从 `fromIndex` 位置开始搜索
_.lastIndexOf([1, 2, 1, 2], 2, 2);
// => 1

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

引入版本 4.11.0

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

参数

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

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

示例

var array = ["a", "b", "c", "d"];

_.nth(array, 1);
// => 'b'

_.nth(array, -2);
// => 'c'

_.pull(array, [values])

引入版本 2.0.0

移除数组 array 中所有和给定值相等的元素，使用 SameValueZero 进行相等比较。

注意： 和 _.without 不同，这个方法会改变（mutate）原数组。如果不希望改变原数组，请使用 _.without。如果希望根据条件函数移除元素，请使用 _.remove。

参数

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

(Array): 返回 array（修改后的原数组）。

示例

var array = ["a", "b", "c", "a", "b", "c"];

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

_.pullAll(array, values)

引入版本 4.0.0

这个方法类似 _.pull，区别在于它接受一个数组 values 作为要移除的值。

注意： 不同于 _.difference，这个方法会改变（mutate）原数组。

参数

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

引入版本 4.0.0

这个方法类似 _.pullAll，区别在于它接受一个 iteratee（迭代函数），调用该函数处理 array 和 values 中的每个元素，以生成比较的标准。

iteratee 调用时会传入一个参数：(value)。

注意： 不同于 _.differenceBy，这个方法会改变（mutate）原数组。

参数

array (Array): 要修改的数组。
values (Array): 要移除的值的数组。
[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])

引入版本 4.6.0

这个方法类似 _.pullAll，区别在于它接受一个 comparator（比较器），调用该函数来比较 array 和 values 中的元素。

comparator 调用时会传入两个参数：(arrVal, othVal)。

注意： 不同于 _.differenceWith，这个方法会改变（mutate）原数组。

参数

array (Array): 要修改的数组。
values (Array): 要移除的值的数组。
[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])

引入版本 3.0.0

根据指定的索引（indexes）从 array 中移除元素，并返回由被移除元素组成的新数组。

注意： 不同于 _.at，这个方法会改变（mutate）原数组。

参数

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

引入版本 2.0.0

移除数组 array 中 predicate（断言函数）返回为真值（truthy）的所有元素，并返回一个由被移除元素组成的新数组。

predicate 调用时会传入三个参数：(value, index, array)。

注意： 不同于 _.filter，这个方法会改变（mutate）原数组。如果想根据值来移除元素，请使用 _.pull。

参数

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

引入版本 4.0.0

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

注意： 这个方法会改变（mutate）原数组，它是基于 Array#reverse 的。

参数

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

引入版本 3.0.0

创建一个数组切片，从 start 位置开始，直到 end 位置结束（但不包含 end 位置）。

注意： 这个方法用于替代 Array#slice，以确保返回的是密集数组（dense arrays）。

参数

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

(Array): 返回数组的切片。

示例

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

_.slice(array, 2);
// => [3, 4]

_.sortedIndex(array, value)

引入版本 0.1.0

使用二分查找（binary search）来确定 value 应该插入到数组 array 中的 最小索引 位置，以保证数组的排序顺序不变。

参数

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

(number): 返回 value 应该插入到数组中的索引位置。

示例

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

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

引入版本 4.0.0

这个方法类似 _.sortedIndex，区别在于它接受一个 iteratee（迭代函数），调用该函数处理 value 和 array 中的每个元素，以计算它们的排序排名。

iteratee 调用时会传入一个参数：(value)。

参数

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

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

示例

var objects = [{ x: 4 }, { x: 5 }];

_.sortedIndexBy(objects, { x: 4 }, function (o) {
  return o.x;
});
// => 0

// 使用 `_.property` 的迭代器简写
_.sortedIndexBy(objects, { x: 4 }, "x");
// => 0

_.sortedIndexOf(array, value)

引入版本 4.0.0

该方法类似 _.indexOf，区别在于它是在 已排序 的数组上执行二分查找（binary search）。

参数

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

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

示例

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

_.sortedLastIndex(array, value)

引入版本 3.0.0

此方法类似 _.sortedIndex，区别在于它返回 value 应该插入到数组 array 中的 最高索引 位置（即插入到所有相同元素的后面），以保证数组的排序顺序不变。

参数

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

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

示例

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

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

引入版本 4.0.0

这个方法类似 _.sortedLastIndex，区别在于它接受一个 iteratee（迭代函数），调用该函数处理 value 和 array 中的每个元素，以计算它们的排序排名。

iteratee 调用时会传入一个参数：(value)。

参数

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

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

示例

var objects = [{ x: 4 }, { x: 5 }];

_.sortedLastIndexBy(objects, { x: 4 }, function (o) {
  return o.x;
});
// => 1

// 使用 `_.property` 的迭代器简写
_.sortedLastIndexBy(objects, { x: 4 }, "x");
// => 1

_.sortedLastIndexOf(array, value)

引入版本 4.0.0

该方法类似 _.lastIndexOf，区别在于它是在 已排序 的数组上执行二分查找（binary search）。

参数

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

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

示例

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

_.sortedUniq(array)

引入版本 4.0.0

这个方法类似 _.uniq，区别在于它专为 已排序 数组设计并进行了优化。

参数

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

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

示例

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

_.sortedUniqBy(array, [iteratee])

引入版本 4.0.0

这个方法类似 _.uniqBy，区别在于它专为 已排序 数组设计并进行了优化。

参数

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

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

示例

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

_.tail(array)

引入版本 4.0.0

获取除了数组第一个元素以外的全部元素。

参数

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

(Array): 返回数组的切片。

示例

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

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

引入版本 0.1.0

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

参数

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

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

引入版本 3.0.0

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

参数

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

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

引入版本 3.0.0

创建一个数组切片，从 array 数组的末尾开始提取元素。元素提取会一直进行，直到 predicate（断言函数）返回假值（falsey）。

predicate 调用时会传入三个参数：(value, index, array)。

参数

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

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

// 使用 `_.matches` 的迭代器简写
_.takeRightWhile(users, { user: "pebbles", active: false });
// => objects for ['pebbles']

// 使用 `_.matchesProperty` 的迭代器简写
_.takeRightWhile(users, ["active", false]);
// => objects for ['fred', 'pebbles']

// 使用 `_.property` 的迭代器简写
_.takeRightWhile(users, "active");
// => []

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

引入版本 3.0.0

创建一个数组切片，从 array 数组的开头开始提取元素。元素提取会一直进行，直到 predicate（断言函数）返回假值（falsey）。

predicate 调用时会传入三个参数：(value, index, array)。

参数

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

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

// 使用 `_.matchesProperty` 的迭代器简写
_.takeWhile(users, ["active", false]);
// => objects for ['barney', 'fred']

// 使用 `_.property` 的迭代器简写
_.takeWhile(users, "active");
// => []

_.union([arrays])

引入版本 0.1.0

创建一个按顺序排列的唯一值数组（即求数组的并集）。所有给定数组中的元素都会被包含在内，并使用 SameValueZero 进行相等比较。

参数

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

(Array): 返回包含合并后元素的新数组。

示例

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

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

引入版本 4.0.0

这个方法类似 _.union，区别在于它接受一个 iteratee（迭代函数），调用该函数处理每一个数组中的每个元素，以生成唯一性计算的标准。结果值从该值出现的第一个数组中选择。

iteratee 调用时会传入一个参数：(value)。

参数

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

(Array): 返回包含合并后元素的新数组。

示例

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

// 使用 `_.property` 的迭代器简写
_.unionBy([{ x: 1 }], [{ x: 2 }, { x: 1 }], "x");
// => [{ 'x': 1 }, { 'x': 2 }]

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

引入版本 4.0.0

这个方法类似 _.union，区别在于它接受一个 comparator（比较器），调用该函数来比较 arrays 中的元素。结果值从该值出现的第一个数组中选择。

comparator 调用时会传入两个参数：(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 },
];

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

_.uniq(array)

引入版本 0.1.0

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

参数

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

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

示例

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

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

引入版本 4.0.0

这个方法类似 _.uniq，区别在于它接受一个 iteratee（迭代函数），调用该函数处理数组中的每个元素，以生成唯一性计算的标准。结果值的顺序由它们在原数组中出现的顺序决定。

iteratee 调用时会传入一个参数：(value)。

参数

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

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

示例

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

引入版本 4.0.0

这个方法类似 _.uniq，区别在于它接受一个 comparator（比较器），调用该函数来比较数组中的元素。结果值的顺序由它们在原数组中出现的顺序决定。

comparator 调用时会传入两个参数：(arrVal, othVal)。

参数

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

引入版本 1.2.0

这个方法类似 _.zip，区别在于它接收一个打包（grouped）元素的数组，然后创建一个数组，将元素重组为它们在 zip 之前的结构。（即 _.zip 的逆操作）。

参数

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

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

引入版本 3.8.0

该方法类似 _.unzip，区别在于它接受一个 iteratee（迭代函数）来指定重组后的值应该如何被组合。

iteratee 调用时会传入每个分组的元素：(...group)。

参数

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

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

示例

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

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

_.without(array, [values])

引入版本 0.1.0

创建一个新数组，其中不包含任何被排除的 values（值）。该方法使用 SameValueZero 进行相等比较。

注意： 不同于 _.pull，这个方法会返回一个新数组（不会改变原数组）。

参数

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

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

示例

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

_.xor([arrays])

引入版本 2.4.0

创建一个包含所有给定数组 对称差集 的唯一值数组。（即：元素存在于某一个数组中，但不同时存在于其他数组中）。结果值的顺序由它们在数组中出现的顺序决定。

参数

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

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

示例

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

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

引入版本 4.0.0

这个方法类似 _.xor，区别在于它接受一个 iteratee（迭代函数），调用该函数处理每一个数组中的每个元素，以生成比较的标准。结果值的顺序由它们在数组中出现的顺序决定。

iteratee 调用时会传入一个参数：(value)。

参数

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

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

示例

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

// 使用 `_.property` 的迭代器简写
_.xorBy([{ x: 1 }], [{ x: 2 }, { x: 1 }], "x");
// => [{ 'x': 2 }]

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

引入版本 4.0.0

这个方法类似 _.xor，区别在于它接受一个 comparator（比较器），调用该函数来比较 arrays 中的元素。结果值的顺序由它们在数组中出现的顺序决定。

comparator 调用时会传入两个参数：(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])

引入版本 0.1.0

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

参数

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

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

示例

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

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

引入版本 0.4.0

这个方法类似 _.fromPairs，区别在于它接受两个数组，一个包含属性名，另一个包含对应的值。

参数

[props=[]] (Array): 属性名数组。
[values=[]] (Array): 属性值数组。

(Object): 返回新对象。

示例

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

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

引入版本 4.1.0

这个方法类似 _.zipObject，区别在于它支持属性路径（property paths）。

参数

[props=[]] (Array): 属性标识符（路径）数组。
[values=[]] (Array): 属性值数组。

(Object): 返回新对象。

示例

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

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

引入版本 3.8.0

该方法类似 _.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]

Array (数组) ​

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

参数 ​

返回 ​

示例 ​

_.compact(array) ​

参数 ​

返回 ​

示例 ​

_.concat(array, [values]) ​

参数 ​

返回 ​

示例 ​

_.difference(array, [values]) ​

参数 ​

返回 ​

示例 ​

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

参数 ​

返回 ​

示例 ​

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

参数 ​

返回 ​

示例 ​

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

参数 ​

返回 ​

示例 ​

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

参数 ​

返回 ​

示例 ​

_.dropRightWhile(array, [predicate=_.identity]) ​

参数 ​

返回 ​

示例 ​

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

参数 ​

返回 ​

示例 ​

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

参数 ​

返回 ​

示例 ​

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

参数 ​

返回 ​

示例 ​

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

参数 ​

返回 ​

示例 ​

_.flatten(array) ​

参数 ​

返回 ​

示例 ​

_.flattenDeep(array) ​

参数 ​

返回 ​

示例 ​

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

参数 ​

返回 ​

示例 ​

_.fromPairs(pairs) ​

参数 ​

返回 ​

示例 ​

_.head(array) ​

参数 ​

返回 ​

示例 ​

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

参数 ​

返回 ​

示例 ​

_.initial(array) ​

参数 ​

返回 ​

Array (数组)

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

参数

返回

示例

_.compact(array)

参数

返回

示例

_.concat(array, [values])

参数

返回

示例

_.difference(array, [values])

参数

返回

示例

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

参数

返回

示例

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

参数

返回

示例

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

参数

返回

示例

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

参数

返回

示例

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

参数

返回

示例

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

参数

返回

示例

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

参数

返回

示例

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

参数

返回

示例

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

参数

返回

示例

_.flatten(array)

参数

返回

示例

_.flattenDeep(array)

参数

返回

示例

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

参数

返回

示例

_.fromPairs(pairs)

参数

返回

示例

_.head(array)

参数

返回

示例

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

参数

返回

示例

_.initial(array)

参数

返回