©
Dieses Dokument verwendet PHP-Handbuch für chinesische Websites Freigeben
_.chunk(array, size=1)
创建一个元素数组，分成长度为size。如果array不能均匀分割，最后的块将成为剩余的元素。
初始值
3.0.0
参数
array（Array）：要处理的数组。[size=1]（大小）：每个块的长度
返回值
（Array）：返回新的数组块。
示例
_.chunk(['a', 'b', 'c', 'd'], 2);// => [['a', 'b'], ['c', 'd']] _.chunk(['a', 'b', 'c', 'd'], 3);// => [['a', 'b', 'c'], ['d']]
_.compact(array)
创建一个数组，其中删除所有falsey值。以下的值——false，null，0，""，undefined，和NaN是 falsey。
初始
0.1.0
参数
array（Array）：要压缩的数组。
返回值
（Array）：返回新的过滤值数组。
示例
_.compact([0, 1, false, 2, '', 3]);// => [1, 2, 3]
_.concat(array, values)
创建array与任何其他数组和/或值连接的新数组。
初始
4.0.0
参数
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)
array使用SameValueZero相等性比较创建未包含在其他给定数组中的值数组。结果值的顺序和引用由第一个数组确定。
注意：与_.pullAll此不同，此方法返回一个新数组。
初始
0.1.0
参数
array（Array）：要检查的数组。[values]（... Array）：要排除的值。
返回值
（Array）：返回新的过滤值数组。
示例
_.difference([2, 1], [2, 3]);// => [1]
_.differenceBy(array, values, iteratee=_.identity)
这种方法类似于_.difference，不同的是它接受iteratee 并为每个元素调用array并values生成它们进行比较的标准。结果值的顺序和引用由第一个数组确定。迭代器因此调用一个参数：
(value).
注意：与_.pullAllBy此不同，此方法返回一个新数组。
初始
4.0.0
参数
array（Array）：要检查的数组。[values]（... Array）：要排除的值。[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)
这种方法与_.difference类似，不同之处在于它接受 comparator被调用来比较的元素array到values。结果值的顺序和引用由第一个数组确定。比较器因此调用两个参数：（arrVal，othVal）。
注意：与_.pullAllWith此不同，此方法返回一个新数组。
初始
4.0.0
参数
array(Array): The array to inspect.[values](...Array): The values to exclude.[comparator](Function): The comparator invoked per element.
返回
（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)
创建n元素从一开始就下降的部分array
初始
0.5.0
参数
array（Array）：要查询的数组。[n=1]（数字）：要删除的元素数量。
返回
（数组）：返回部分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)
创建从最后开始使用n删除元素的一部分array
初始
3.0.0
参数
array（Array）：要查询的数组。[n=1]（数字）：要删除的元素数量。
返回
（数组）：返回一部分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)
创建一个array从结尾删除的排除元素的片段。元素被丢弃，直到predicate返回falsey。谓词用三个参数调用：（value，index，array）。
初始
3.0.0
参数
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']
// 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)
创建从初始删除的排除元素的一部分array。元素被丢弃，直到 predicate返回falsey。谓词用三个参数调用：（value，index，array）。
初始
3.0.0
参数
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']
// 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)
填充的元素array与value来自start为止，但不包括end。
注意： 此方法发生变化array。
初始
3.2.0
参数
array（Array）：要填充的数组。value（*）：填写的值array。[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)
这个方法就像_.find，不同的是它返回第一个元素的索引，predicate返回truthy而不是元素本身。
初始
1.1.0
参数
array（Array）：要检查的数组。[predicate=_.identity]（Function）：每次迭代调用的函数。[fromIndex=0]（number）：从中搜索的索引。
返回
（number）：返回找到的元素的索引，else -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)
这个方法就像_.findIndex，不同的是它遍历collection 从右到左的元素。
初始
2.0.0
参数
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
// 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)
以单一的深度统一array
初始
0.1.0
参数
array（数组）：要平化的数组。
返回
（ Array ）：返回新的展平数组。
示例
_.flatten([1, [2, [3, [4]], 5]]); // => [1, 2, [3, [4]], 5]
_.flattenDeep(array)
递归地平化array。
初始
3.0.0
参数
array（Array）：要平化的数组。
返回
（Array）：返回新的展平数组。
示例
_.flattenDeep([1, [2, [3, [4]], 5]]); // => [1, 2, 3, 4, 5]
_.flattenDepth(array, depth=1)
递归平化array高达depth倍。
初始
4.4.0
参数
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)
相反的_.toPairs; 此方法返回由键值组成的对象 pairs。
初始
4.0.0
参数
pairs(Array): 值键对
返回
（Object）：返回新的对象。
示例
_.fromPairs([['a', 1], ['b', 2]]);
// => { 'a': 1, 'b': 2 }_.head(array)
获取array的第一个元素。
初始
0.1.0
别名
_.first
参数
array（Array）：要查询的数组。
返回
（*）：返回array的第一个元素。
示例
_.head([1, 2, 3]);// => 1 _.head([]);// => undefined
_.indexOf(array, value, fromIndex=0)
获取在其中第一次出现的索引，与value中被发现array使用SameValueZero的相等比较。如果fromIndex为负值，则将其用作从结尾开始的偏移量array。
初始
0.1.0
参数
array（Array）：要检查的数组。value（*）：要搜索的值。[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)
获得array中除了最后一个元素之外的所有元素
初始
0.1.0
参数
array（Array）：要查询的数组。
返回
（Array）：返回部分array。
示例
_.initial([1, 2, 3]); // => [1, 2]
_.intersection(arrays)
创建一个包含在所有给定数组中的唯一值数组，SameValueZero用于相等性比较。结果值的顺序和引用由第一个数组确定。
初始
0.1.0
参数
[arrays]（... Array）：要检查的数组。
返回
（Array）：返回相交值的新数组。
示例
_.intersection([2, 1], [2, 3]); // => [2]
_.intersectionBy(arrays, iteratee=_.identity)
这种方法类似于_.intersection，不同的是它接受 iteratee为每个元素的每个元素调用arrays以生成它们进行比较的标准。结果值的顺序和引用由第一个数组确定。迭代器因此调用一个参数：
(value).
初始
4.0.0
参数
[arrays]（... Array）：要检查的数组。[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)
这个方法类似于_.intersection不同的是它接受comparator哪个被调用来比较元素arrays。结果值的顺序和引用由第一个数组确定。比较器调用两个参数：（arrVal，othVal）。
初始
4.0.0
参数
[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=',')
将array中所有元素转换为由separator分隔的字符串
初始
4.0.0
参数
array（Array）：要转换的数组。[separator=',']（string）：元素分隔符。
返回
（string）：返回连接的字符串。
示例
_.join(['a', 'b', 'c'], '~'); // => 'a~b~c'
_.last(array)
获取array最后一个元素。
初始
0.1.0
参数
array（Array）：要查询的数组。
返回
（*）：返回array的最后一个元素。
示例
_.last([1, 2, 3]); // => 3
_.lastIndexOf(array, value, fromIndex=array.length-1)
这个方法就像_.indexOf，不同的是它遍历array 从右到左的元素。
初始
0.1.0
参数
array（Array）：要检查的数组。value（*）：要搜索的值。[fromIndex=array.length-1]（number）：从中搜索的索引。
返回
（number）：返回匹配值的索引，否则返回-1。
示例
_.lastIndexOf([1, 2, 1, 2], 2); // => 3 // Search from the `fromIndex`._.lastIndexOf([1, 2, 1, 2], 2, 2);// => 1
_.nth(array, n=0)
获取索引n处的元素array。如果n是负数，则返回从结尾开始的第n个元素。
初始
4.11.0
参数
array（Array）：要查询的数组。[n=0]（number）：要返回的元素的索引。
返回
（*）：返回array的第n个元素。
示例
var array = ['a', 'b', 'c', 'd']; _.nth(array, 1);// => 'b' _.nth(array, -2);// => 'c';
_.pull(array, values)
将删除所有给定值array用SameValueZero平等地比较。
注意：与_.without不同，此方法会发生使array变化，用_.remove谓词从数组中移除元素。
初始
2.0.0
参数
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)
这个方法就像_.pull，不同的是它接受一个要移除的值的数组。
注意：与_.difference此不同，此方法会使array发生变化。
初始
4.0.0
参数
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)
这种方法类似于_.pullAll，不同的是它接受iteratee为每个元素调用array并values生成它们进行比较的标准。迭代器调用一个参数：（value）。
注意：与_.differenceBy此不同，此方法会使array发生变化。
初始
4.0.0
参数
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)
这种方法如_.pullAll，不同之处在于它接受comparator 被调用来比较的元素array到values。比较器被调用两个参数：（arrVal，othVal）。
注意：与_.differenceWith不同，此方法会使array发生变化。
初始
4.6.0
参数
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)
从array相应的元素中移除元素indexes并返回一个已移除元素的数组。
注意：与_.at此不同，此方法会使array发生变化 。
初始
3.0.0
参数
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)
从array移除所有元素，predicate返回truthy并返回删除的元素的阵列。谓词用三个参数调用：（value，index，array）。
注意： 与_.filter此不同，此方法会使之发生变化。用于_.pull通过值从数组中提取元素。
初始
2.0.0
参数
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)
反转array使第一个元素成为最后一个，第二个元素成为倒数第二个元素，依此类推。
注意：此方法变异于array并基于Array#reverse。
初始
4.0.0
参数
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)
创建一个array从start一直到但不包括自身的部分end。
注意：此方法用于Array#slice 以确保返回密集数组。
初始
3.0.0
参数
array（Array）：要切片的数组。[start=0]（number）：开始位置。[end=array.length]（number）：结束位置。
返回
（Array）：返回部分array。
_.sortedIndex(array, value)
使用二进制搜索来确定value应该插入的最低索引即array的最低索引以便维护其排序顺序。
初始
0.1.0
参数
array（Array）：要检查的排序数组。value（*）：要评估的值。
返回
（number）：返回value应插入的索引array。
例
_.sortedIndex([30, 50], 40);// => 1
_.sortedIndexBy(array, value, iteratee=_.identity)
这个方法就像_.sortedIndex,不同的是它接受 iteratee调用的方法value和每个元素array来计算它们的排序顺序。迭代器被调用一个参数：（value）。
初始
4.0.0
参数
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
// The `_.property` iteratee shorthand.
_.sortedIndexBy(objects, { 'x': 4 }, 'x');// => 0_.sortedIndexOf(array, value)
这种方法就像_.indexOf，不同的是它在排序后执行二分搜索 array。
初始
4.0.0
参数
array（Array）：要检查的数组。value（*）：要搜索的值。
返回
（number）：返回匹配值的索引，否则返回-1。
例
_.sortedIndexOf([4, 5, 5, 5, 6], 5);// => 1
_.sortedLastIndex(array, value)
这个方法就像_.sortedIndex，不同的是它返回value应该插入array的最高索引，以便维护它的排序顺序。
初始
3.0.0
参数
array（Array）：要检查的排序数组。value（*）：要评估的值。
返回
（number）：返回value应插入array的索引。
例
_.sortedLastIndex([4, 5, 5, 5, 6], 5);// => 4
_.sortedLastIndexBy(array, value, iteratee=_.identity)
这个方法就像_.sortedLastIndex，不同的是它接受iteratee 调用的方法value和每个元素array来计算它们的排序顺序。迭代器被调用一个参数：（value）。
初始
4.0.0
参数
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
// The `_.property` iteratee shorthand.
_.sortedLastIndexBy(objects, { 'x': 4 }, 'x');// => 1_.sortedLastIndexOf(array, value)
这种方法就像_.lastIndexOf，不同的是它在排序后执行二分搜索array。
初始
4.0.0
参数
array（Array）：要检查的数组。value（*）：要搜索的值。
返回
（number）：返回匹配值的索引，否则返回-1。
例
_.sortedLastIndexOf([4, 5, 5, 5, 6], 5);// => 3
_.sortedUniq(array)
这种方法就像_.uniq，不同的是它为排序数组设计和优化的。
初始
4.0.0
参数
array（Array）：要检查的数组。
返回
（Array）：返回新的重复空闲数组。
例
_.sortedUniq([1, 1, 2]);// => [1, 2]
_.sortedUniqBy(array, iteratee)
这种方法就像_.uniqBy，不同的是它是为排序数组设计和优化的。
初始
4.0.0
参数
array（Array）：要检查的数组。[iteratee]（Function）：每个元素调用的迭代器。
返回
（Array）：返回新的重复空闲数组。
例
_.sortedUniqBy([1.1, 1.2, 2.3, 2.4], Math.floor);// => [1.1, 2.3]
_.tail(array)
除了第一个元素之外，都获得array的所有元素。
初始
4.0.0
参数
array（Array）：要查询的数组。
返回
（Array）：返回部分array。
例
_.tail([1, 2, 3]);// => [2, 3]
_.take(array, n=1)
使用n从头开始的元素创建一部分array。
初始
0.1.0
参数
array（Array）：要查询的数组。[n=1]（number）：要采取的元素数量。
返回
（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)
创建一个从最终获得的n元素的一部分array
初始
3.0.0
参数
array（Array）：要查询的数组。[n=1]（number）：要采取的元素数量。
返回
（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)
创建一个从最后采取的元素的一部分array。提取元素，直到 predicate返回falsey为止。谓词用三个参数调用：（value，index，array）。
初始
3.0.0
参数
array（Array）：要查询的数组。[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)
使用从头开始的元素创建一部分array。提取元素直到predicate 返回false为止。谓词用三个参数调用：（value，index，array）。
初始
3.0.0
参数
array（Array）：要查询的数组。[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)
从所有给定的数组中依次创建一个唯一值数组，SameValueZero用于相等性比较。
初始
0.1.0
参数
[arrays]（... Array）：要检查的数组。
返回
（Array）：返回组合值的新数组。
例
_.union([2], [1, 2]);// => [2, 1]
_.unionBy(arrays, iteratee=_.identity)
这种方法类似，_.union，不同之处在于它接受iteratee为每个元素调用每个元素arrays以生成唯一性计算标准。结果值从第一个出现值的数组中选择。迭代器被调用一个参数：
(value).
初始
4.0.0
参数
[arrays]（... Array）：要检查的数组。[iteratee=_.identity]（Function）：每个元素调用的迭代器。
返回
（Array）：返回组合值的新数组。
例
_.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)
这个方法类似于_.union，不同的是它接受comparator哪个被调用来比较元素arrays。结果值从第一个出现值的数组中选择。比较器被调用两个参数：（arrVal，othVal）。
初始
4.0.0
参数
[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)
创建数组的无重复版本，SameValueZero用于相等比较，其中只保留每个元素的第一个匹配项。结果值的顺序由它们在数组中出现的顺序决定。
初始
0.1.0
参数
array（Array）：要检查的数组。
返回
（Array）：返回新的重复空闲数组。
例
_.uniq([2, 1, 2]);// => [2, 1]
_.uniqBy(array, iteratee=_.identity)
此方法类似于_.uniq，不同的是它接受iteratee为每个元素调用array以生成唯一性计算标准的方法。结果值的顺序由它们在数组中出现的顺序决定。迭代器被调用一个参数：
(value).
初始
4.0.0
参数
array（Array）：要检查的数组。[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)
这个方法类似于_.uniq，不同的是它接受comparator哪个被调用来比较元素array。结果值的顺序由它们在数组中出现的顺序决定。使用两个参数调用比较器：（arrVal，othVal）。
初始
4.0.0
参数
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)
这种方法就像_.zip，不同的是它接受一个分组元素数组，并创建一个数组，将这些元素重新组合到它们的pre-zip配置中。
初始
1.2.0
参数
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)
这种方法就像_.unzip，不同的是它接受iteratee指定应该如何组合重组值。迭代器用每个组的元素调用： （... group）。
初始
3.8.0
参数
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)
使用SameValueZero相等比较创建排除所有给定值的数组。
注意：与_.pull不同，此方法返回一个新数组。
初始
0.1.0
参数
array（Array）：要检查的数组。[values]（... *）：要排除的值。
返回
（Array）：返回新的过滤值数组。
例
_.without([2, 1, 2, 3], 1, 2);// => [3]
_.xor（阵列）
创建一个唯一值的数组，它是给定数组的对称差异。结果值的顺序由它们在数组中出现的顺序决定。
初始
2.4.0
参数
[arrays]（... Array）：要检查的数组。
返回
（Array）：返回新的过滤值数组。
例
_.xor([2, 1], [2, 3]);// => [1, 3]
_.xorBy(arrays, iteratee=_.identity)
这种方法就像_.xor，不同的是它接受iteratee为每个元素调用每个元素arrays来生成他们所比较的标准。结果值的顺序由它们在数组中出现的顺序决定。迭代器被调用一个参数：（value）。
初始
4.0.0
参数
[arrays]（... Array）：要检查的数组。[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)
这个方法类似于_.xor，不同的是它接受comparator哪个被调用来比较元素arrays。结果值的顺序由它们在数组中出现的顺序决定。比较器被调用两个参数：（arrVal，othVal）。
初始
4.0.0
参数
[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=[]])
这个方法就像_.fromPairs，它接受两个数组，一个属性标识符和一个相应的值。
初始
0.4.0
参数
[props=[]]（Array）：属性标识符。[values=[]]（Array）：属性值。
返回
（Object）：返回新的对象。
例
_.zipObject(['a', 'b'], [1, 2]);
// => { 'a': 1, 'b': 2 }_.zipObjectDeep([props=[]], [values=[]])
这种方法就像_.zipObject,它支持属性路径。
初始
4.1.0
参数
[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)
这个方法就像_.zip,它接受iteratee指定应该如何组合分组值。迭代器用每个组的元素调用：（... group）。
初始
3.8.0
参数
[arrays]（... Array）：要处理的数组。[iteratee=_.identity]（Function）：组合分组值的功能。
返回
（Array）：返回分组元素的新数组。
例
_.zipWith([1, 2], [10, 20], [100, 200], function(a, b, c) { return a + b + c;});
// => [111, 222]