Lodash教程--（3）“集合”⽅法（“Collection”Methods）
Lodash教程--（3）“集合”⽅法（“Collection” Methods）
(1)_.countBy(collection, [iteratee= _.identity])
创建⼀个组成对象，key（键）是经过 iteratee（迭代函数） 执⾏处理collection中每个元素后返回的结果，每个key（键）对应的值是iteratee（迭代函数）返回该key（键）的次数（愚⼈码头注：迭代次数）。 iteratee 调⽤⼀个参数：(value)。
collection (Array|Object): ⼀个⽤来迭代的集合。
[iteratee=_.identity] (Array|Function|Object|string): ⼀个迭代函数，⽤来转换key（键）。
_.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 }
(2)_.every(collection, [predicate= _.identity])
通过 predicate（断⾔函数） 检查 collection（集合）中的 所有 元素是否都返回真值。⼀旦 predicate（断⾔函数） 返回假值，迭代就马上停⽌。predicate（断⾔函数）调⽤三个参数： (value, index|key, collection)。
_.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
(3)_.filter(collection, [predicate= _.identity])
遍历 collection（集合）元素，返回 predicate（断⾔函数）返回真值 的所有元素的数组。 predicate（断⾔函数）调⽤三个参数：(value, index|key, collection)。
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']
(4)_.find(collection, [predicate= _.identity], [fromIndex=0])
遍历 collection（集合）元素，返回 predicate（断⾔函数）第⼀个返回真值的第⼀个元素。predicate（断⾔函数）调⽤3个参数：(value, index|key, collection)。
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'
(5)_.findLast(collection, [predicate= _.identity], [fromIndex=collection.length-1])
这个⽅法类似_.find ，不同之处在于，_.findLast是从右⾄左遍历collection （集合）元素的。
collection (Array|Object): ⼀个⽤来迭代的集合。
[predicate=_.identity] (Array|Function|Object|string): 每次迭代调⽤的函数。
[fromIndex=collection.length-1] (number): 开始搜索的索引位置。
_.findLast([1,2,3,4],function(n){
return n %2==1;
});
// => 3
(6)_.flatMap(collection, [iteratee= _.identity])
创建⼀个扁平化（同阶数组）的数组，这个数组的值来⾃collection（集合）中的每⼀个值经过 iteratee（迭代函数） 处理后返回的结果，并且扁平化合并。 iteratee 调⽤三个参数： (value, index|key, collection)。
function duplicate(n){
return[n, n];
}
_.flatMap([1,2], duplicate);
// => [1, 1, 2, 2]
(7)_.flatMapDeep(collection, [iteratee= _.identity])
lodash有哪些方法这个⽅法类似 _.flatMap 不同之处在于，_.flatMapDeep 会继续扁平化递归映射的结果。
function duplicate(n){
return[[[n, n]]];
}
_.flatMapDeep([1,2], duplicate);
/
/ => [1, 1, 2, 2]
(8)_.flatMapDepth(collection, [iteratee= _.identity], [depth=1])
该⽅法类似_.flatMap，不同之处在于，_.flatMapDepth 会根据指定的 depth（递归深度）继续扁平化递归映射结果。
function duplicate(n){
return[[[n, n]]];
}
_.flatMapDepth([1,2], duplicate,2);
// => [[1, 1], [2, 2]]
(9)_.forEach(collection, [iteratee= _.identity])
调⽤ iteratee 遍历 collection(集合) 中的每个元素， iteratee 调⽤3个参数： (value, index|key, collection)。 如果迭代函数（iteratee）显式的返回 false ，迭代会提前退出。
_([1,2]).forEach(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).
(10)_.forEachRight(collection, [iteratee= _.identity])
这个⽅法类似 _.forEach，不同之处在于，_.forEachRight 是从右到左遍历集合中每⼀个元素的。
_.forEachRight([1,2],function(value){
console.log(value);
});
// => Logs `2` then `1`.
(11)_.groupBy(collection, [iteratee= _.identity])
创建⼀个对象，key 是 iteratee 遍历 collection(集合) 中的每个元素返回的结果。 分组值的顺序是由他们出现在 collection(集合) 中的顺序确定的。每个键对应的值负责⽣成 key 的元素组成的数组。iteratee 调⽤ 1 个参数： (value)。
_.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'] }`
(12) _.includes(collection, value, [fromIndex=0])
检查 value(值) 是否在 collection(集合) 中。如果 collection(集合)是⼀个字符串，那么检查 value（值，⼦字符串） 是否在字符串中，否则使⽤ SameValueZero 做等值⽐较。 如果指定 fromIndex 是负数，那么从 collection(集合) 的结尾开始检索。
_.includes([1,2,3],1);
// => true
_.includes([1,2,3],1,2);
// => false
_.includes({'user':'fred','age':40},'fred');
// => true
_.includes('pebbles','eb');
// => true
(13)_.invokeMap(collection, path, [args])
调⽤path（路径）上的⽅法处理 collection(集合)中的每个元素，返回⼀个数组，包含每次调⽤⽅法得到的结果。任何附加的参数提供给每个被调⽤的⽅法。如果methodName（⽅法名）是⼀个函数，每次调⽤函数时，内部的 this 指向集合中的每个元素。
_.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']]
(14)_.keyBy(collection, [iteratee= _.identity])
创建⼀个对象组成， key（键） 是 collection（集合）中的每个元素经过 iteratee（迭代函数） 处理后返回的结果。 每个 key（键）对应的值是⽣成key（键）的最后⼀个元素。iteratee（迭代函数）调⽤1个参数：(value)。
var array =[
{'dir':'left','code':97},
{'dir':'right','code':100}
];
_.keyBy(array,function(o){
return String.de);
});
// => { 'a': { 'dir': 'left', 'code': 97 }, 'd': { 'dir': 'right', 'code': 100 } }
_.keyBy(array,'dir');
// => { 'left': { 'dir': 'left', 'code': 97 }, 'right': { 'dir': 'right', 'code': 100 } }
(15)_.map(collection, [iteratee= _.identity])
创建⼀个数组， value（值） 是 iteratee（迭代函数）遍历 collection（集合）中的每个元素后返回的结果。
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']
(16)_.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}
];
// 以 `user` 升序排序再  `age` 以降序排序。
_.orderBy(users,['user','age'],['asc','desc']);
// => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 40]]
(17)_.partition(collection, [predicate= _.identity])
创建⼀个分成两组的元素数组，第⼀组包含predicate（断⾔函数）返回为 truthy（真值）的元素，第⼆组包含predicate（断⾔函数）返回为 falsey（假值）的元素。predicate 调⽤1个参数：(value)。
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']]
(18)_.reduce(collection, [iteratee= _.identity], [accumulator])

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。