Lodash工具库Collection学习

一、Collection

这里讲解较为常用的方法。

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

创建一个组成对象，key（键）是经过 iteratee（迭代函数） 执行处理collection中每个元素后返回的结果，每个key（键）对应的值是 iteratee（迭代函数）返回该key（键）的次数（注：迭代次数）。 iteratee 调用一个参数：(value)。

var countBy = _.countBy(['one', 'two', 'three'], 'length');//循环数组元素的length
console.log(countBy);

.groupBy(collection, [iteratee=.identity])
创建一个对象，key 是 iteratee 遍历 collection(集合) 中的每个元素返回的结果。 分组值的顺序是由他们出现在 collection(集合) 中的顺序确定的。每个键对应的值负责生成 key 的元素组成的数组。iteratee 调用 1 个参数： (value)。

var groupBy = _.groupBy(['one', 'two', 'three'], 'length');
console.log(groupBy);//将结果列举

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

调用path（路径）上的方法处理 collection(集合)中的每个元素，返回一个数组，包含每次调用方法得到的结果。任何附加的参数提供给每个被调用的方法。如果methodName（方法名）是一个函数，每次调用函数时，内部的 this 指向集合中的每个元素。

var invokeMap = _.invokeMap([[5, 1, 7], [3, 2, 1]], 'sort');
var _invokeMap = _.invokeMap([146,259],String.prototype.split,'');
//用第二参数处理第一个参数
console.log(invokeMap,_invokeMap);

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

创建一个对象组成， key（键） 是 collection（集合）中的每个元素经过 iteratee（迭代函数） 处理后返回的结果。 每个 key（键）对应的值是生成key（键）的最后一个元素。iteratee（迭代函数）调用1个参数：(value)。

var keyByArr = [{ 'dir': 'left', 'code': 97 },
                { 'dir': 'right', 'code': 100 }];
var keyBy = _.keyBy(keyByArr, function(o) {
  return String.fromCharCode(o.code);
});
console.log(keyByArr);

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

此方法类似于_.sortBy，除了它允许指定 iteratee（迭代函数）结果如何排序。 如果没指定 orders（排序），所有值以升序排序。 否则，指定为"desc" 降序，或者指定为 “asc” 升序，排序对应值。

var users = [{ 'user': 'fred',   'age': 48 },
             { 'user': 'barney', 'age': 34 },
             { 'user': 'fred',   'age': 40 },
             { 'user': 'barney', 'age': 36 }];
// `asc` 升序排序 ,`desc` 以降序排序。
var res1 = _.orderBy(users,'age','asc');
var res2 = _.orderBy(users, ['user', 'age'], ['asc', 'desc']);// 以 `user` 升序排序 再  `age` 以降序排序。
console.log(res1,res2);

.sortBy(collection, [iteratees=[.identity]])
创建一个元素数组。 以 iteratee 处理的结果升序排序。 这个方法执行稳定排序，也就是说相同元素会保持原始排序。 iteratees 调用1个参数： (value)。

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

创建一个分成两组的元素数组，第一组包含predicate（断言函数）返回为 truthy（真值）的元素，第二组包含predicate（断言函数）返回为 falsey（假值）的元素。predicate 调用1个参数：(value)。

var partitionArr = [{ 'user': 'barney',  'age': 36, 'active': false },
             { 'user': 'fred',    'age': 40, 'active': true },
             { 'user': 'pebbles', 'age': 1,  'active': false }];
var partition1 = _.partition(partitionArr, function(o) { return o.active; });
var partition2 = _.partition(partitionArr, { 'age': 1, 'active': false });
console.log(partition1,partition2);//按参数进行拆分

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

_.filter的反向方法;此方法 返回 predicate（断言函数） 不 返回 truthy（真值）的collection（集合）元素（注释：非真）。

var rejectArr = [{ 'user': 'barney', 'age': 36, 'active': false },
                 { 'user': 'fred',   'age': 40, 'active': true }];
var reject1 = _.reject(rejectArr, function(o) { return !o.active; });
var reject2 = _.reject(rejectArr, { 'age': 40, 'active': true });
console.log(reject1,reject2);//按参数过滤

7_.sample(collection)

从collection（集合）中获得一个随机元素

var sample = _.sample([1, 2, 3, 4]);
console.log(sample);//数组中随机一位

_.sampleSize(collection, [n=1])
从collection（集合）中获得 n 个随机元素。

var sampleSize = _.sampleSize([1, 2, 4,6], 2);
console.log(sampleSize);//数组中随机两位

_.shuffle(collection)
创建一个被打乱值的集合。 使用 Fisher-Yates shuffle 版本。

var shuffle = _.shuffle([1, 2, 3, 4]);
console.log(shuffle);//打乱数组里顺序

8_.size(collection)

返回collection（集合）的长度，如果集合是类数组或字符串，返回其 length ；如果集合是对象，返回其可枚举属性的个数。

console.log(_.size([1, 2, 3]));//3
console.log(_.size({ 'a': 1,'b': 2}));//2
console.log(_.size('Thissize'));//8