lodash - 集合
获取指定元素
nth（指定下标）
// 获取数组中指定下标的元素
_.nth(array, [n=0]);
_.nth(['a', 'b', 'c', 'd'], 1);
// => 'b'
head/first（第一个元素）
// 获取数组的第一个元素
_.head(array);
_.first(array);
_.head([1, 2, 3]);
// => 1
// 获取数组的第一个元素
_.first([1, 2, 3]);
// => 1
last（最后一个元素）
// 获取数组的最后一个元素
_.last(array);
_.last([1, 2, 3]);
// => 3
find（迭代器，正向匹配）
// 正向遍历
// 返回迭代器第一个返回 true 的元素
_.find(collection, [predicate=_.identity], [fromIndex=0]);
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（迭代器，反向匹配）
// 反向遍历
// 返回迭代器第一个返回 true 的元素
_.findLast(collection, [predicate=_.identity], [fromIndex=collection.length-1]);
_.findLast([1, 2, 3, 4], function(n) {
return n % 2 === 1;
});
// => 3
范围选择元素
slice（下标区域选择）
// 选取从 start 到 end 的元素
// 注意：不包括 end
_.slice(array, [start=0], [end=array.length])
_.slice([1, 2, 3, 4], 0, 3);
// => [1, 2, 3];
tail（第一个元素外的所有元素）
// 选取数组第一个元素之外
// 所有其他元素
_.tail(array);
_.tail([1, 2, 3]);
// => [2, 3]
initial（最后一个元素外的所有元素）
// 选择数组最后一个元素之外
// 所有其他元素
_.initial(array);
_.initial([1, 2, 3]);
// => [1, 2]
take（开头或结尾的 n 个元素）
// 选取数组开头的 n 个元素
_.take(array, [n=1]);
// 选取数组结尾的 n 个元素
_.takeRight(array, [n=1]);
// 通过迭代器
// 从开头选择元素
// 直到迭代器返回 false
_.takeWhile(array, [predicate=_.identity]);
// 通过迭代器
// 从结尾选择元素
// 直到迭代器返回 false
_.takeRightWhile(array, [predicate=_.identity]);
_.take([1, 2, 3], 2);
// => [1, 2]
_.takeRight([1, 2, 3], 2);
// => [2, 3]
_.takeWhile([1, 2, 3, 4, 5, 6], num => num < 4);
// => [1, 2, 3]
_.takeRightWhile([1, 2, 3, 4, 5, 6], num => num > 4);
// => [5, 6]
drop（头或尾元素之外的其余元素）
// 选取去掉开头的前 n 个元素之外的所有其他元素
_.drop(array, [n=1]);
// 返回去掉结尾的 n 个元素之外的所有其他元素
_.dropRight(array, [n=1]);
// 从开头到结尾循环删除，直到返回 false 为止，返回剩下的元素
_.dropWhile(array, [predicate=_.identity]);
// 从结尾到开头循环删除，直到返回 false 为止，返回剩下的元素
_.dropRightWhile(array, [predicate=_.identity]);
_.drop([1, 2, 3], 2);
// => [3]
_.dropRight([1, 2, 3], 2);
// => [1]
_.dropWhile([ 1, 2, 3 ], num => num < 3);
// => [3]
_.dropRightWhile([ 1, 2, 3 ], num => num > 1);
// => [1]
寻找元素下标
indexOf（全等匹配）
// 从前向后
// 全等比较
// 返回下标
// 没找到会返回 -1
_.indexOf(array, value, [fromIndex=0]);
// 从后向前
// 全等比较
// 返回下标
// 没找到会返回 -1
_.lastIndexOf(array, value, [fromIndex=array.length-1]);
_.indexOf([1, 2, 1, 2], 2, 2);
// => 3
_.lastIndexOf([1, 2, 1, 2], 2);
// => 3
findIndex（迭代器匹配）
// 从前向后
// 通过判断器判断是否相等
// 返回为 true 时的下标
_.findIndex(array, [predicate=_.identity], [fromIndex=0]);
// 从后向前
// 通过判断器判断是否相等
// 返回为 true 时的下标
_.findLastIndex(array, [predicate=_.identity], [fromIndex=array.length-1]);
_.findIndex([ 1, 2, 3, 4, 5 ], num => num === 5);
// => 4
_.findLastIndex([ 1, 2, 3, 4, 5 ], num => num === 5);
// => 4
sortedIndexOf（没理解啥意思）
// 没理解啥意思........
// 这个方法类似 _.indexOf，除了它是在已经排序的数组array上执行二进制检索。
_.sortedIndexOf(array, value);
// 没理解啥意思........
_.sortedLastIndexOf(array, value);
删除元素
without（传入指定元素，返回新数组）
_.without(array, [values]);
_.without([2, 1, 2, 3], 1, 2);
// => [3]
difference（传入数组, 返回新数组）
// 删除数组中指定的元素，全等比较
_.difference(array, [ values ]);
// 通过迭代器将元素进行转换后（返回值）再进行比较
// 返回元素转化前的新数组
_.differenceBy(array, [values], [iteratee=_.identity]);
// 根据判断器的返回值（true 或 false），判断是否相等
_.differenceWith(array, [values], [comparator]);
_.difference([ 3, 2, 1 ], [ 4, 2 ]);
// => [ 3, 1 ]
_.differenceBy([ 3.1, 2.2, 1.3 ], [ 4.4, 2.5 ], Math.floor);
// => [ 3.1, 1.3 ]
_.differenceBy([{ 'x': 2 }, { 'x': 1 }], [{ 'x': 1 }], 'x');
// => [{ 'x': 2 }]
_.differenceWith(
[{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }],
[{ 'x': 1, 'y': 2 }],
_.isEqual
);
// => [{ 'x': 2, 'y': 1 }]
pull（传入无限制，影响源数组）
// 指定元素
// 全等比较删除
// 返回源数组
_.pull(array, [values]);
// 指定元素数组
// 全等比较删除
// 返回源数组
_.pullAll(array, values);
// 将元素通过迭代器转换
// 将转换后的值进行比较
// 返回源数组（数组中元素为转换前的值）
_.pullAllBy(array, values, [iteratee=_.identity]);
// 根据判断器进行比较
// 根据返回值 true 或 false
// 判断两值是否相等
// 返回源数组
_.pullAllWith(array, values, [comparator]);
// 根据索引移出相应元素
// 返回删除的元素组成的数组
_.pullAt(array, [indexes]);
_.pull([1, 2, 3, 1, 2, 3], 2, 3);
// => [1, 1]
_.pullAll([1, 2, 3, 1, 2, 3], [2, 3]);
// => [1, 1]
_.pullAllBy([{ 'x': 1 }, { 'x': 2 }, { 'x': 3 }, { 'x': 1 }], [{ 'x': 1 }, { 'x': 3 }], 'x');
// => [{ 'x': 2 }]
_.pullAllWith(
[{ 'x': 1, 'y': 2 }, { 'x': 3, 'y': 4 }, { 'x': 5, 'y': 6 }],
[{ 'x': 3, 'y': 4 }],
_.isEqual
);
// => [{ 'x': 1, 'y': 2 }, { 'x': 5, 'y': 6 }]
var array = [5, 10, 15, 20];
var evens = _.pullAt(array, 1, 3);
console.log(array);
// => [5, 15]
console.log(evens);
// => [10, 20]
remove（传入判断器，影响源数组）
_.remove(array, [predicate=_.identity]);
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]
判断
includes（全等判断，某元素是否存在）
// 如果指定 fromIndex 是负数，那么从 collection(集合) 的结尾开始检索
// 返回 true 或 false
_.includes(collection, value, [fromIndex=0]);
_.includes([1, 2, 3], 1);
// => true
_.includes([1, 2, 3], 1, 2);
// => false
_.includes({ 'user': 'fred', 'age': 40 }, 'fred');
// => true
_.includes('pebbles', 'eb');
// => true
some（判断器判断，某元素是否存在）
返回 true 或 false
// 若判断器返回了 true
// 会立刻停止遍历
// 返回结果
_.some(collection, [predicate=_.identity])
_.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
every（是否是全真集合）
// 通过迭代器判断数组中是否全都为真
// 返回 true 或 false
_.every(collection, [predicate=_.identity]);
_.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（真元素集合）
// 遍历数组
// 根据迭代器的返回值
// 筛选出为 true 的元素
// 返回新数组
_.filter(collection, [predicate=_.identity]);
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']
reject（假元素集合）
返回新数组
// 遍历数组
// 通过迭代器的返回值
// 筛选出为假值的集合
// 返回新数组
_.reject(collection, [predicate=_.identity])
var users = [
{ 'user': 'barney', 'age': 36, 'active': false },
{ 'user': 'fred', 'age': 40, 'active': true }
];
_.reject(users, function(o) { return !o.active; });
// => objects for ['fred']
// `_.matches` 迭代简写
_.reject(users, { 'age': 40, 'active': true });
// => objects for ['barney']
// `_.matchesProperty` 迭代简写
_.reject(users, ['active', false]);
// => objects for ['fred']
// `_.property` 迭代简写
_.reject(users, 'active');
// => objects for ['barney']
partition（真假元素集合）
返回新数组
// 将集合按照迭代器的返回值分为 ['真', '假'] 两个数组
// 返回新数组
_.partition(collection, [predicate=_.identity]);
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']]
排序
sortBy（迭代器，升序排序）
返回新数组
PS：可以不传第二个参数，默认就和原生方法 sort 一样，升序排序。
_.sortBy(collection, [iteratees=[_.identity]])
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]]
_.sortBy(users, 'user', function(o) {
return Math.floor(o.age / 10);
});
// => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 40]]
orderBy（迭代器，多次排序）
返回新数组
// 通常用于对象集合排序
// 可指定多个属性排序（asc，desc）
// 返回新数组
_.orderBy(collection, [iteratees=[_.identity]], [orders]);
var users = [
{ 'user': 'fred', 'age': 48 },
{ 'user': 'barney', 'age': 34 },
{ 'user': 'fred', 'age': 40 },
{ 'user': 'barney', 'age': 36 }
];
// 以 `user` 升序排序 再 `age` 以降序排序。
_.orderBy(users, ['user', 'age'], ['asc', 'desc']);
// => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 40]]
合并
concat（拼接）
// 和 Array.prototype.concat 一样
_.concat(array, [values]);
_.concat([1], 2, [3], [[4]]);
// => [1, 2, 3, [4]]
union（合并，去重）
// 返回新数组
_.union([arrays]);
// 先将元素通过迭代器转换
// 合并，去重
// 返回新数组，元素为转换前
_.unionBy([arrays], [iteratee=_.identity]);
// 根据判断器判断两值是否相等
// 合并，去重
// 返回新数组
_.unionWith([arrays], [comparator]);
_.union([2], [1, 2]);
// => [2, 1]
_.unionBy([2.1], [1.2, 2.3], Math.floor);
// => [2.1, 1.2]
// 对象数组可简写
_.unionBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x');
// => [{ 'x': 1 }, { 'x': 2 }]
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 }]
intersection（筛选交集，去重）
// 筛选出传入的数组中都包含的元素
// 返回新数组
_.intersection([arrays]);
// 先将元素通过迭代器转换
// 再筛选出转换后的值的交集
// 返回新数组
_.intersectionBy([arrays], [iteratee=_.identity]);
// 通过判断器，判断两值是否相等
// 筛选交集
// 返回新数组
_.intersectionWith([arrays], [comparator]);
_.intersection([2, 1], [4, 2], [1, 2]);
// => [2]
_.intersectionBy([2.1, 1.2], [4.3, 2.4], Math.floor);
// => [2.1]
_.intersectionBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x');
// => [{ 'x': 1 }]
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 }]
xor（筛选唯一，去重）
// 筛选出传入的多个数组中，唯一的元素
// 返回新数组
_.xor([arrays]);
// 先将元素通过迭代器转换
// 再筛选出多个数组中的唯一值
// 返回新数组，元素为转换前的
_.xorBy([arrays], [iteratee=_.identity]);
// 根据判断器，判断两值是否相等
// 筛选出多个数组中，唯一存在的值
// 返回新数组
_.xorWith([arrays], [comparator]);
_.xor([2, 1, 1, 1, 1], [2, 3]);
// => [1, 3]
_.xorBy([2.1, 1.2], [2.3, 3.4], Math.floor);
// => [1.2, 3.4]
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 }]
去重
uniq
// 全等去重
_.uniq(array);
// 先将值通过迭代器转换
// 比较转换后的值去重
// 返回新数组
_.uniqBy(array, [iteratee=_.identity]);
// 通过判断器，判断两值是否相等
// 进行去重
// 返回新数组
_.uniqWith(array, [comparator]);
_.uniq([2, 1, 2]);
// => [2, 1]
_.uniqBy([2.1, 1.2, 2.3], Math.floor);
// => [2.1, 1.2]
_.uniqBy([{ 'x': 1 }, { 'x': 2 }, { 'x': 1 }], 'x');
// => [{ 'x': 1 }, { 'x': 2 }]
_.uniqWith(
[{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 2 }],
_.isEqual
);
// => [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]
去假值
compact（数组去假值）
// 去除数组中的假值
// false, null, 0, "", undefined, 和 NaN 都是被认为是假值
// 返回新数组
_.compact(array);
_.compact([0, 1, false, 2, '', 3]);
// => [1, 2, 3]
随机
sample（随机获取一个元素）
返回元素
_.sample(collection);
_.sample([1, 2, 3, 4]);
// => 2
sampleSize（随机获取 n 个元素）
返回新数组
_.sampleSize(collection, [n=1])
_.sampleSize([1, 2, 3], 2);
// => [3, 1]
_.sampleSize([1, 2, 3], 4);
// => [2, 3, 1]
shuffle（打乱数组）
返回新数组
_.shuffle(collection)
_.shuffle([1, 2, 3, 4]);
// => [4, 1, 3, 2]
求和
reduce（正向）
返回结果
// 遍历集合
// 通过迭代器累加值
// 最终返回结果
_.reduce(collection, [iteratee=_.identity], [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'] } (无法保证遍历的顺序)
reduceRight（反向）
返回结果
// 同 reduce
// 不过遍历顺序是反向的
_.reduceRight(collection, [iteratee=_.identity], [accumulator])
var array = [[0, 1], [2, 3], [4, 5]];
_.reduceRight(array, function(flattened, other) {
return flattened.concat(other);
}, []);
// => [4, 5, 2, 3, 0, 1]
分组
groupBy（返回新对象）
// 按照迭代器的返回值进行分组
// 返回新对象
_.groupBy(collection, [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'] }
chunk（数组分块）
// 按照 size 将数组分成若干小小组
// 返回新的二维数组
_.chunk(array, [size=1]);
_.chunk(['a', 'b', 'c', 'd'], 3);
// => [['a', 'b', 'c'], ['d']]
遍历
迭代函数中只要返回了 false 就会立刻停止循环
each（正向遍历）
_.each(collection, [iteratee=_.identity]);
_.forEach(collection, [iteratee=_.identity]);
_([1, 2]).each(function(value) {
console.log(value);
});
// => Logs `1` then `2`.
eachRight（反向遍历）
_.eachRight(collection, [iteratee=_.identity]);
_.forEachRight(collection, [iteratee=_.identity]);
_.forEachRight([1, 2], function(value) {
console.log(value);
});
// => Logs `2` then `1`.
遍历，返回结果
map
返回新数组
// 通过迭代器处理值
// 并返回结果，组成新数组
// 返回新数组
_.map(collection, [iteratee=_.identity]);
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']
invokeMap（和 map 差不多）
返回新数组
_.invokeMap(collection, path, [args]);
_.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']]
填充数组
fill（用字符填充数组，改变源数组）
// 用指定字符串填充指定区域
// 注意 end 不包含
// 改变源数组
_.fill(array, value, [start=0], [end=array.length]);
_.fill([4, 6, 8, 10], '*', 1, 3);
// => [4, '*', '*', 10]
降维
flatten（数组降维）
// 降一级
// 返回新数组
_.flatten(array);
// 递归降维，将为一维数组
// 返回新数组
_.flattenDeep(array);
// 指定降多少级
// 返回新数组
_.flattenDepth(array, [depth=1]);
_.flatten([1, [2, [3, [4]], 5]]);
// => [1, 2, [3, [4]], 5]
_.flattenDeep([1, [2, [3, [4]], 5]]);
// => [1, 2, 3, 4, 5]
_.flattenDepth([1, [2, [3, [4]], 5]], 2);
// => [1, 2, 3, [4], 5]
数组转对象
keyBy（迭代器返回值为 key）
返回新对象
// 根据迭代器的返回值当做 key
// value 为返回 key 的最后一个元素
// 组成新对象
_.keyBy(collection, [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 } }
fromPairs（二维数组转为对象）
// 二维数组转为对象
// 返回新对象
_.fromPairs(pairs);
_.fromPairs([['fred', 30], ['barney', 40]]);
// => { 'fred': 30, 'barney': 40 }
拼接字符串
join
// 同 Array.prototype.join
_.join(array, [separator=',']);
_.join(['a', 'b', 'c'], '~');
// => 'a~b~c'
翻转
reverse（数组翻转）
// 会改变源数组
_.reverse([1, 2, 3]);
// => [3, 2, 1]
插入位置计算
sortedIndex
// 计算 value 在 array 中
// 尽可能小的排序位置
// 返回下标
_.sortedIndex(array, value);
// 计算 value 在 array 中
// 尽可能大的排序位置
// 返回下标
_.sortedLastIndex(array, value);
// 根据迭代器的返回值计算尽可能小的位置
// 通常用于对象简写
// 返回位置
_.sortedIndexBy(array, value, [iteratee=_.identity]);
// 根据迭代器的返回值计算尽可能大的位置
// 通常用于对象简写
// 返回位置
_.sortedLastIndexBy(array, value, [iteratee=_.identity]);
_.sortedIndex([30, 50], 40);
// => 1
_.sortedLastIndex([4, 5, 5, 5, 6], 5);
// => 4
_.sortedIndexBy(
[{ 'x': 4 }, { 'x': 5 }],
{ 'x': 4 },
'x'
);
// => 0
_.sortedLastIndexBy(
[{ 'x': 4 }, { 'x': 5 }],
{ 'x': 4 },
'x'
);
// => 1
数组组合
zip
// 将传入的多个数组
// 按照下标组合
// 返回二维数组
_.zip([arrays]);
// 将传入的多个数组，按照迭代器进行组合
_.zipWith([arrays], [iteratee=_.identity]);
// 第一个参数为 key 数组，第二位数组为 value 数组，组合成一个对象
_.zipObject([props=[]], [values=[]]);
// 类似于 zipObject，可以指定 path
_.zipObjectDeep([props=[]], [values=[]]);
// _.zip 的方向版，将二位数组拆分成多个数组
_.unzip(zipped);
// 通过迭代器拆分
_.unzipWith(array, [iteratee=_.identity]);
_.zip(['fred', 'barney'], [30, 40], [true, false]);
// => [['fred', 30, true], ['barney', 40, false]]
_.zipWith([1, 2], [10, 20], [100, 200], function(a, b, c) {
return a + b + c;
});
// => [111, 222]
_.zipObject(['a', 'b'], [1, 2]);
// => { 'a': 1, 'b': 2 }
_.zipObjectDeep(['a.b[0].c', 'a.b[1].d'], [1, 2]);
// => { 'a': { 'b': [{ 'c': 1 }, { 'd': 2 }] } }
_.unzip(['fred', 'barney'], [30, 40], [true, false]);
// => [['fred', 'barney'], [30, 40], [true, false]]
_.unzipWith([[1, 10, 100], [2, 20, 200]], _.add);
// => [3, 30, 300]
统计次数
countBy（统计次数）
// 将迭代器的返回值作为 key，value 为 key 返回的次数
// 返回新对象
_.countBy(collection, [iteratee=_.identity]);
_.countBy([6.1, 4.2, 6.3], Math.floor);
// => { '4': 1, '6': 2 }
创建扁平化数组
flatMap
// 迭代器返回的值都会默认降维一级
// 返回新数组
_.flatMap(collection, [iteratee=_.identity]);
// 递归降维
// 返回新数组
_.flatMapDeep(collection, [iteratee=_.identity]);
// 指定降维级数
// 返回新数组
_.flatMapDepth(collection, [iteratee=_.identity], [depth=1]);
_.flatMap([1, 2], function (n) {
return [n, n];
});
// => [1, 1, 2, 2]
_.flatMapDeep([1, 2], function (n) {
return [[[n, n]]];
});
// => [1, 1, 2, 2]
_.flatMapDepth([1, 2], function (n) {
return [[[n, n]]];
}, 2);
// => [[1, 1], [2, 2]]
创建范围数组
range（正序，从 start 到 end 的数组）
返回新数组
_.range([start=0], end, [step=1]);
_.range(4);
// => [0, 1, 2, 3]
_.range(-4);
// => [0, -1, -2, -3]
_.range(1, 5);
// => [1, 2, 3, 4]
_.range(0, 20, 5);
// => [0, 5, 10, 15]
_.range(0, -4, -1);
// => [0, -1, -2, -3]
_.range(1, 4, 0);
// => [1, 1, 1]
_.range(0);
// => []
rangeRight（降序，从 end 到 start 的数组）
_.rangeRight([start=0], end, [step=1]);
_.rangeRight(4);
// => [3, 2, 1, 0]
_.rangeRight(-4);
// => [-3, -2, -1, 0]
_.rangeRight(1, 5);
// => [4, 3, 2, 1]
_.rangeRight(0, 20, 5);
// => [15, 10, 5, 0]
_.rangeRight(0, -4, -1);
// => [-3, -2, -1, 0]
_.rangeRight(1, 4, 0);
// => [1, 1, 1]
_.rangeRight(0);
// => []
长度
size
如果集合是类数组或字符串，返回其 length
如果集合是对象，返回其可枚举属性的个数。
_.size(collection);
_.size([1, 2, 3]);
// => 3
_.size({ 'a': 1, 'b': 2 });
// => 2
_.size('pebbles');
// => 7