lodash库——封装好的collection集合函数-阿里云开发者社区

lodash库——封装好的collection集合函数

2024-04-25 30

版权

本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。

简介： lodash库——封装好的collection集合函数

集合collection

Array数组
set集合（存储的元素是有序不重复的）
Map集合（存储的元素以键值对key:value的形式）

let array=['y','m','a',1,6]
let set={}
let map=[{'value1':1,'value2':2}]

countBy—返回组成对象

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

创建构建集合对象

key———经过iterratee执行的结果

value———相同结果执行key的次数

let temp=[19.49,2.5,2.2,2.8,19.98,20.20]
let result=_.countBy(temp,Math.round);
console.log(result)

forEach方法—遍历元素

forEach(collection,[iteratee=_.identity])

调用iteratee遍历collection，可以访问key和value

let temp={'yma16':16,'china':1949}
let result=_.forEach(temp,(key,value)=>{
console.log('key:',key,'value',value)
})
console.log(result)

扩展

each(collection,[iteratee=_.identity])

作用于forEach相同

forEachRight(collection,[iteratee=_.identity])

从右到左开始遍历

let temp={'yma16':16,'china':1949}
let result=_.forEachRight(temp,(key,value)=>{
console.log('key:',key,'value',value)
})
console.log(result)

every方法—判断数据

every(collection,[predicate=_.identity])

根据predicate的定义判断，若遇到假值，则停止切返回boolean的false

返回的是boolea类型

let temp=[1,2,3,null]
let result=_.every(temp,Boolean)
console.log(result)

filter方法—留下真值

filter(collection,predicate=_.identity)

遍历集合，根据predicate过滤掉满足不满足的元素

留下满足的元素（真值）

返回过滤后的数组

let user=[
{'name':'yma16','active':true},
{'name':'yam16','active':false},
]
let result=_.filter(user,(o)=>{return o.active})
console.log(result)

注意：reject方法与filter相反

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

留下不满足predicate的元素（假值）

let user=[
{'name':'yma16','active':true},
{'name':'yam16','active':false},
]
let result=_.reject(user,(o)=>{return o.active})
console.log(result)

find方法—查找满足条件的第一个元素

find(collection,[predicate=_.identity],[fromindex=0])

便利collection集合的元素，返回第一个满足条件的真值

let user=[
{'user':'yma16','active':true},
{'name':'yam16','active':false},
{'name':'chinese','active':true}
]
let result=_.find(user,o=>{return o.active})
console.log(result)

扩展

findLast(collection,[predicate=_.identity],[fromindex=0])

从右到左开始查找，查到即返回

let user=[
{'user':'yma16','active':true},
{'name':'yam16','active':false},
{'name':'chinese','active':true}
]
let result=_.findLast(user,o=>{return o.active})
console.log(result)

flatMap方法—创建同阶数组

flatMap(collection,[predicate=_.identity])

同阶数组（平级）

let temp=[6]
let result=_.flatMap(temp,o=>{return [o,o,o]})
console.log(result)

扩展

flatMapDeep(collection,[predicate=_.identity])

完全是同等级

flatMapDepth(collection,[predicate=_.identity],[depth=1])

指定执行次数

let temp=[[[[6]]]]
let result1=_.flatMap(temp,o=>{return [o,o,o]})
let result2=_.flatMapDeep(temp,o=>{return [o,o,o]})
let result3=_.flatMapDepth(temp,o=>{return [o,o,o]},2)
console.log(result1)
console.log(result2)
console.log(result3)

groupBy方法—创建对象

groupBy(collection,[iteratee=_.identity])

与countBy方法相似,创建构建集合对象

key——是遍历元素计算的结果

value——是生成key的数组（countBy是key的迭代次数）

let temp=[19.49,2.5,2.2,2.8,19.98,20.20]
let result=_.groupBy(temp,Math.round);
console.log(result)

includes方法—是否包括

includes(collection,value,[fromindex=0])

可以检查字符串的子串是否存在

返回boolean

let result=_.includes([1,2,3],1)
console.log(result)

invokeMap方法—path方法处理

invokeMap(collection,path,[args])

调用path上的方法处理集合元素，返回一个对象数组（调用方法得到的结果）

let temp=[[1,2,3,2,1,],['a','b','c','b','a']]
let result=_.invokeMap(temp,'sort')
console.log(result)

keyBy方法—创建对象（自定义key）

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

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

let user=[
{'user':'yma16','active':1},
{'name':'yam16','active':2},
{'name':'chinese','active':3}
]
let result=_.keyBy(user,o=>{return o.active})
console.log(result)

map方法—创建数组

map(collection,[iteratee=_.identity])

返回进过迭代结果组成的数组

let temp=[3,5]
let result=_.map(temp,o=>{return o*o})
console.log(result)

orderBy方法—排序

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

回想mysql的orderb排序（asc、desc）

let user=[
{'name':'yma16','active':1},
{'name':'yma16','active':2},
{'name':'chinese','active':3}
]
let result=_.orderBy(user,['name','active'],['asc','desc'])
console.log(result)

sortBy(collection,[iteratee= _.identity],[orders])

创建一个元素数组迭代后升序

let user=[
{'name':'yma16','active':1},
{'name':'yma16','active':2},
{'name':'chinese','active':3}
]
let result=_.sortBy(user,o=>{return o.name})
console.log(result)

partiton方法—划分为数组

partition(collection,[iteratee= _.identity])

返回数组对象包含两个数组

第一个数组—true

第二个数组—false

let user=[
{'name':'yma16','active':true},
{'name':'yam16','active':false},
{'name':'chinese','active':true}
]
let result=_.partition(user,o=>{return o.active})
console.log(result)

reduce方法—返回累加后的值

reduce(collection, [iteratee=_.identity], [accumulator])

accumulator为第一个迭代的值（定义返回类型），遍历集合的元素，返回值进入下次迭代

let temp={'yma16':16,'yma17':17,'yma18':18}
let result=_.reduce(temp,(result,key,value)=>{
(result[value]||(result[value]=[])).push(key)
return result
},{})
console.log(result)

扩展

reduceRight(collection, [iteratee=_.identity], [accumulator])

从右边到左边

sample（随机元素）、shuffle（乱序）、size（长度）方法

sample(collection,[n=1])随机取n个元素

let temp=[1,2,3,4,5,6,7]
console.log(_.sample(temp))
console.log(_.shuffle(temp))
console.log(_.size(temp))