加强网站建设和维护,亦庄建设局网站,phpcms移动端网站怎么做,抖音代运营的好处正在替代 lodash 的新JS工具, 旧的 lodash 语法太老, 新的 radash 集合了 ES6 语法, 效率更高
安装 :
npm i radash
常用API整理 :
数组 API :
1. 数组排序 alphabetical
按字母顺序, 正序倒序排列
import { alphabetical } from radashconst gods [{name: Ra,power: …正在替代 lodash 的新JS工具, 旧的 lodash 语法太老, 新的 radash 集合了 ES6 语法, 效率更高
安装 :
npm i radash
常用API整理 :
数组 API :
1. 数组排序 alphabetical
按字母顺序, 正序倒序排列
import { alphabetical } from radashconst gods [{name: Ra,power: 100},{name: Zeus,power: 98},{name: Loki,power: 72},{name: Vishnu,power: 100}
]alphabetical(gods, g g.name) // [Loki, Ra, Vishnu, Zeus]
alphabetical(gods, g g.name, desc) // [Zeus, Vishnu, Ra, Loki]
2. 取数组最大最小值 boil
import { boil } from radashconst gods [{name: Ra,power: 100},{name: Zeus,power: 98},{name: Loki,power: 72}
]boil(gods, (a, b) (a.power b.power ? a : b))
// { name: Ra, power: 100 }
3. 拆分指定长度数组, 组成二维数组 cluster
import { cluster } from radashconst gods [Ra, Zeus, Loki, Vishnu, Icarus, Osiris, Thor, Apollo, Artemis, Athena]cluster(gods, 3)
// [
// [ Ra, Zeus, Loki ],
// [ Vishnu, Icarus, Osiris ],
// [Thor, Apollo, Artemis],
// [Athena]
// ]
4. 统计数组元素出现的次数 counting
import { counting } from radashconst gods [{name: Ra,culture: egypt},{name: Zeus,culture: greek},{name: Loki,culture: greek}
]counting(gods, g g.culture) // { egypt: 1, greek: 2 }
5. 获取数组的第一个元素, 如果不存在任何项目则返回第一个项目或默认值 first
import { first } from radashconst gods [ra, loki, zeus]first(gods) // ra
first([], vishnu) // vishnu
6. 展平多维数组 flat
import { flat } from radashconst gods [[ra, loki], [zeus]]flat(gods) // [ra, loki, zeus]
7. 对数组对象以某个元素进行分组 group
import { group } from radashconst fish [{name: Marlin,source: ocean},{name: Bass,source: lake},{name: Trout,source: lake}
]const fishBySource group(fish, f f.source)// 输出 fishBySource
{ocean: [{name: Marlin,source: ocean}],lake: [{name: Bass,source: lake},{name: Trout,source: lake}]
}
8. 判断两个数组中元素是否有相同 intersects
import { intersects } from radashconst oceanFish [tuna, tarpon]
const lakeFish [bass, trout]intersects(oceanFish, lakeFish) // falseconst brackishFish [tarpon, snook]intersects(oceanFish, brackishFish) // true
9. 获取数组最后一个元素 如果不存在任何项目则返回最后一个项目或默认值 last
import { last } from radashconst fish [marlin, bass, trout]const lastFish last(fish) // trout
const lastItem last([], bass) // bass
9. 返回数组中最大值 max
import { max } from radashconst fish [{name: Marlin,weight: 105,source: ocean},{name: Bass,weight: 8,source: lake},{name: Trout,weight: 13,source: lake}
]max(fish, f f.weight) // {name: Marlin, weight: 105, source: ocean}
10. 合并数组对象, 并覆盖相同 key 值的对象 merge
import { merge } from radashconst gods [{name: Zeus,power: 92},{name: Ra,power: 97}
]const newGods [{name: Zeus,power: 100}
]merge(gods, newGods, f f.name)
// [{name: Zeus power: 100}, {name: Ra, power: 97}]
11. 返回数组中最小值 min
import { min } from radashconst fish [{name: Marlin,weight: 105,source: ocean},{name: Bass,weight: 8,source: lake},{name: Trout,weight: 13,source: lake}
]min(fish, f f.weight) // {name: Bass, weight: 8, source: lake}
12. 替换数组元素, 仅替换第一个匹配项 replace
import { replace } from radashconst fish [{name: Marlin,weight: 105},{name: Bass,weight: 8},{name: Trout,weight: 13}
]const salmon {name: Salmon,weight: 22
}// read: replace fish with salmon where the name is Bass
replace(fish, salmon, f f.name Bass)// 输出
[{name: Marlin,weight: 105},{name: Salmon,weight: 22},{name: Trout,weight: 13}
]
13. 数组元素整体向右移动 n 个位置 shift
import { shift } from radash
const arr [1, 2, 3, 4, 5, 6, 7, 8, 9]
shift(arr, 3) // [7, 8, 9, 1, 2, 3, 4, 5, 6]
14. 过滤出数组中虚假的元素 sift
import { sift } from radashconst fish [salmon, null, false, NaN, sockeye, bass]sift(fish) // [salmon, sockeye, bass]
15. 数组排序, 按照数字大小正序倒序排列 sort
import { sort } from radashconst fish [{name: Marlin,weight: 105},{name: Bass,weight: 8},{name: Trout,weight: 13}
]sort(fish, f f.weight) // [bass, trout, marlin]
sort(fish, f f.weight, true) // [marlin, trout, bass]
16. 数组元素求和 sum
import { sum } from radashconst fish [{name: Marlin,weight: 100},{name: Bass,weight: 10},{name: Trout,weight: 15}
]sum(fish, f f.weight) // 125
17. 数组删除和添加元素, 已包含则删除, 未包含则添加 toggle
import { toggle } from radashconst gods [ra, zeus, loki]toggle(gods, ra) // [zeus, loki]
toggle(gods, vishnu) // [ra, zeus, loki, vishnu]18. 数组去重 unique
import { unique } from radashconst fish [{name: Marlin,weight: 105,source: ocean},{name: Salmon,weight: 22,source: river},{name: Salmon,weight: 22,source: river}
]unique( fish, f f.name )
// [
// { name: Marlin, weight: 105, source: ocean },
// { name: Salmon, weight: 22, source: river }
// ]
19. 两个数组合并成一个对象 zipToObject
import { zipToObject } from radashconst names [ra, zeus, loki]
const cultures [egypt, greek, norse]zipToObject(names, cultures)
// { ra: egypt, zeus: greek, loki: norse }zipToObject(names, (k, i) k i)
// { ra: ra0, zeus: zeus1, loki: loki2 }zipToObject(names, null)
// { ra: null, zeus: null, loki: null }
20. 两个数组压缩成一个二维数组 zip
import { zip } from radashconst names [ra, zeus, loki]
const cultures [egypt, greek, norse]zip(names, cultures)
// [
// [ra, egypt]
// [zeus, greek]
// [loki, norse]
// ]
21. 获取数组随机元素 draw
import { draw } from radashconst fish [marlin, bass, trout]draw(fish) // 随机值
22. 重新随机排列数组元素顺序返回 shuffle
import { shuffle } from radashconst fish [{name: Marlin,weight: 105,source: ocean},{name: Salmon,weight: 22,source: river},{name: Salmon,weight: 22,source: river}
]shuffle(fish)
异步 API :
1. 将多个接口请求返回数据整合成一个数组 或 对象, 统一返回 all
// 将数组作为参数传递将以相同的顺序将解析的 promise 值作为数组返回
import { all } from radashconst [user] await all([api.users.create(...),s3.buckets.create(...),slack.customerSuccessChannel.sendMessage(...)
])// 将对象作为参数传递将返回一个对象该对象具有与解析的 promise 值相同的键和值
import { all } from radashconst { user } await all({user: api.users.create(...),bucket: s3.buckets.create(...),message: slack.customerSuccessChannel.sendMessage(...)
})
2. 不断重复请求, 可设置间隔时间, 直到请求成功或达到指定的最大重试次数 retry
import { retry } from radash; await retry({}, api.users.list)
await retry({ times: 10 }, api.users.list)await retry({ times: 2, delay: 1000 }, api.articles.list);// 在这个例子中retry() 函数尝试执行 api.articles.list 异步操作如果操作失败它会等待 1000 毫秒即 1 秒后重试最多重试 2 次。// 可以使用 retry() 函数来替代传统的异步重试库因为它提供了更加简洁和灵活的接口。结合 Radash 的
// 其他功能如 tryit、parallel 等可以轻松构建出高效且健壮的异步处理逻辑以应对后端服务的各种
// 不确定性。无论是处理网络请求、数据库操作还是其他异步任务retry() 函数都能提供强大的容错能力
// 确保应用程序的稳定性和可靠性
防抖 debounce :
import { debounce } from radash// 请求接口
const getUser async () {const { data } await infUser()
}// 点击按钮
const handleTest debounce({ delay: 2000 }, () {// delay: 2000 间隔时间 毫秒 才请求getUser()
})
节流 throttle :
import { throttle } from radash// 请求接口
const getUser async () {const { data } await infUser()
}const jieLiu throttle({ interval: 2000 }, () {// interval: 2000 间隔 2000 毫秒内只请求 1 次getUser ()
})
获取随机数字 random :
import { random } from radashrandom(0, 100) // 0 到 100 之间随机数字 对象 API :
1. 合并两个对象 assign
import { assign } from radashconst ra {name: Ra,power: 100
}assign(ra, { name: Loki })
// { name: Loki, power: 100 }
2. 浅拷贝 clone
import { clone } from radashconst ra {name: Ra,power: 100
}const gods [{name: Ra,power: 100}
]clone(ra) // copy of ra
clone(gods) // copy of gods
3. 对象 key 和 value 颠倒 invert
import { invert } from radashconst powersByGod {ra: sun,loki: tricks,zeus: lighning
}invert(gods) // { sun: ra, tricks: loki, lightning: zeus }
4. 获取对象所有 key 值 keys
import { keys } from radashconst ra {name: ra,power: 100,friend: {name: loki,power: 80},enemies: [{name: hathor,power: 12}]
}keys(ra)
// [
// name,
// power,
// friend.name,
// friend.power,
// enemies.0.name,
// enemies.0.power
// ]
5. 返回提取对象中指定元素, 组成新对象 pick
import { pick } from radashconst fish {name: Bass,weight: 8,source: lake,barckish: false
}pick(fish, [name, source])// 输出
{name: Bass,source: lake
}
6. 将对象所有 key 转为大写并返回 upperize
import { upperize } from radashconst ra {Mode: god,Power: sun
}upperize(ra)// 输出
{MODE: god,POWER: sun
}
7. 将对象所有 key 转为小写并返回 lowerize
import { lowerize } from radashconst ra {Mode: god,Power: sun
}// 输出
{mode: god,power: sun
}
字符串 API :
1. 将一串字符串以驼峰大小写格式返回 camel
import { camel } from radashcamel(green fish blue fish) // greenFishBlueFish
判断类型 API :
1. 是否数组 isArray
import { isArray } from radashisArray(hello) // false
isArray([hello]) // true
2. 是否日期 isDate
import { isDate } from radashisDate(new Date()) // true
isDate(12) // false
isDate(hello) // false
3. 是否为空 isEmpty
import { isEmpty } from radashisEmpty([]) // true
isEmpty() // true
isEmpty(null) // true
isEmpty({}) // true
isEmpty(0) // true
isEmpty(NaN) // true
isEmpty(undefined) // trueisEmpty(hello) // false
isEmpty([hello]) // false
4. 是否相等 isEqual
import { isEqual } from radashisEqual(null, null) // true
isEqual([], []) // trueisEqual(hello, world) // false
isEqual(22, abc) // false
5. 是否浮点数 isFloat
import { isFloat } from radashisFloat(12.233) // true
isFloat(12) // false
isFloat(hello) // false
6. 是否函数 isFunction
import { isFunction } from radashisFunction(hello) // false
isFunction([hello]) // false
isFunction(() hello) // true
7. 是否数字 isNumber
import { isNumber } from radashisNumber(hello) // false
isNumber([hello]) // false
isNumber(12) // true
8. 是否对象 isObject
import { isObject } from radashisObject(hello) // false
isObject([hello]) // false
isObject(null) // false
isObject({ say: hello }) // true
9. 是否字符串 isString
import { isString } from radashisString(hello) // true
isString([hello]) // false
