radash库方法使用大纲（全）—— 包含所有方法思维导图

前言

大家好，我是阿瓜。一个励志分享更多技术的前端瓜 ~

我们目前已经分享了 radash 库中的所有方法，本篇是所有方法的使用目录，方法源码大家感兴趣的可以前往主页查看阅读；

各位同学可以在本篇查看方法使用，阿瓜也会同步上传所有方法的思维导图使用目录，方便大家查找使用。

思维导图原件可访问 github下载，不能访问外网的同学可访问 gitee下载

数组方法：

alphabetical：把对象数组按照选定key的value的字母顺序排列

用法说明
- 参数：目标对象数组、用于排序的属性的回调函数、第三个参数可选（不传是升序排序，传入desc字符则表示降序排序）；
- 返回值：排序后的数组。

使用代码示例：

import { alphabetical } from 'radash'

const ig = [
  {
    name: 'ning',
    power: 100
  },
  {
    name: 'rookie',
    power: 98
  },
  {
    name: 'jkl',
    power: 95
  },
  {
    name: 'theshy',
    power: 100
  }
]

// 这里输出的依然是对象数组，这里简单表示
alphabetical(ig, g => g.name) // => [jkl, ning, rookie, theshy]  
alphabetical(ig, g => g.name, 'desc') // => [theshy, rookie, ning, jkl]

boil：找出对象数组中满足条件的对象

用法说明：
- 参数：目标对象数组、条件函数；
- 返回值：满足条件的对象。

使用代码示例：

import { boil } from 'radash'

const rng = [
  {
    name: 'Uzi',
    power: 100
  },
  {
    name: 'Xiaohu',
    power: 98
  },
  {
    name: 'Ming',
    power: 72
  }
]
boil(gods, (a, b) => (a.power > b.power ? a : b))  // => { name: 'Uzi', power: 100 }
boil(gods, (a, b) => (a.power < b.power ? a : b))  // => { name: 'Ming', power: 72 }

cluster：把一个数组尽量均匀的分成多个数组

用法说明：
- 参数：目标数组、分组个数n；
- 返回值：分组后的二维数组。

使用代码示例：

import { cluster } from 'radash'

const gods = ['Ra', 'Zeus', 'Loki', 'Vishnu', 'Icarus', 'Osiris', 'Thor', 'Apollo', 'Artemis', 'Athena']

cluster(gods, 3)
// => [
//   [ 'Ra', 'Zeus', 'Loki' ],
//   [ 'Vishnu', 'Icarus', 'Osiris' ],
//   ['Thor', 'Apollo', 'Artemis'],
//   ['Athena']
// ]

counting：统计对象数组中每个唯一标识符的出现次数

用法说明：
- 参数：目标对象数组、条件函数（内部是传入目标对象，返回对象身上的某一项——根据这项来做统计）；
- 返回值：统计对象。

使用代码示例：

import { counting } from 'radash'

const skt = [
  {
    name: 'Ra',
    culture: 'egypt'
  },
  {
    name: 'Zeus',
    culture: 'greek'
  },
  {
    name: 'Loki',
    culture: 'greek'
  }
]

counting(gods, g => g.culture) // => { egypt: 1, greek: 2 }

diff：返回数组 1 中出现但是没在数组 2 中出现的项

用法说明：
- 参数：目标数组1、目标数组2；
- 返回值：包含符合项的数组。

使用代码示例：

import { diff } from 'radash'

const oldWorldGods = ['rng', 'uzi']
const newWorldGods = ['vishnu', 'uzi']

diff(oldWorldGods, newWorldGods) // => ['rng']

first：获取数组第一项，不存在返回默认值

使用说明
- 参数：目标数组，或者传递两个参数空数组和默认值；
- 返回值：传目标数组则返回目标数组的第一项，传空数组和默认值则返回默认值。

使用代码示例

import { first } from 'radash'

const gods = ['lufee', 'loki', 'zeus']

first(gods) // => 'lufee'
first([], 'zuoluo') // => 'zuoluo'

flat：数组扁平化 —— 把包含多个数组的数组转为一个数组（注意不会递归）

使用说明
- 参数：包含多个数组的数组；
- 返回值：降低一维后的数组；
- 注意：不会递归降维，只能降一维。

使用代码示例

import { flat } from 'radash'

const gods = [['shy', 'ning'], ['jkl']]

flat(gods) // => [shy, ning, jkl]

fork：按条件将数组拆分成两个数组，满足条件的一个，不满足条件的一个

使用说明
- 参数：目标数组，条件函数；
- 返回值：返回两个数组，一个保存满足条件的项，另一个保存不满足条件的项。

使用代码示例

import { fork } from 'radash'

const gods = [
  {
    name: 'Uzi',
    power: 100
  },
  {
    name: 'Xiaohu',
    power: 98
  },
  {
    name: 'Ming',
    power: 72
  },
  {
    name: 'Mlxg',
    power: 100
  }
]

const [finalGods, lesserGods] = fork(gods, f => f.power > 90) // [[Uzi, Xiaohu, Mlxg], [Ming]]

group：根据条件函数指定的key构建一个统计对象，key为指定的key有哪些value，value为对应对象

使用说明
- 参数：对象数组、条件函数；
- 返回值：统计对象。

使用代码示例

import { group } from 'radash'

const fish = [
  {
    name: 'Marlin',
    source: 'ocean'
  },
  {
    name: 'Bass',
    source: 'lake'
  },
  {
    name: 'Trout',
    source: 'lake'
  }
]

const fishBySource = group(fish, f => f.source) // => { ocean: [marlin], lake: [bass, trout] }

intersects：判断两个数组是否有公共项，返回一个布尔值

使用说明
- 参数：数组1，数组2，可选条件函数（用于提取随机标识符，对对象数组进行操作时）；
- 返回值：有返回true，否则返回false。

使用代码示例

import { intersects } from 'radash'

const oceanFish = ['tuna', 'tarpon']
const lakeFish = ['bass', 'trout']

intersects(oceanFish, lakeFish) // => false

const brackishFish = ['tarpon', 'snook']

intersects(oceanFish, brackishFish) // => true

iterate：把一个函数迭代执行指定次数

使用说明
- 参数：迭代次数、每次迭代调用的函数、迭代初始值。
- 返回值：返回最终一次循环迭代的值。

使用代码示例

import { iterate } from 'radash'

const value = iterate(
  4,
  (acc, idx) => {
    return acc + idx
  },
  0
) // => 10

last：输出数组的最后一项，如果数组为空则输出传入的默认值

使用说明
- 参数：目标数组，或者空数组和默认值。
- 返回值：数组最后一项，如果数组为空则输出传入的默认值。

使用代码示例

import { last } from 'radash'

const fish = ['marlin', 'bass', 'trout']

const lastFish = last(fish) // => 'trout'
const lastItem = last([], 'bass') // => 'bass'

list：创建包含特定项的数组

使用说明
- 参数：start、end、值，步长。
- 返回值：从start开始遍历到end，输出一个数组，包含特定项（值）的数组。

使用代码示例

import { list } from 'radash'

list(3)                  // [0, 1, 2, 3]
list(0, 3)               // [0, 1, 2, 3]
list(0, 3, 'y')          // [y, y, y, y]
list(0, 3, () => 'y')    // [y, y, y, y]
list(0, 3, i => i)       // [0, 1, 2, 3]
list(0, 3, i => `y${i}`) // [y0, y1, y2, y3]
list(0, 3, obj)          // [obj, obj, obj, obj]
list(0, 6, i => i, 2)    // [0, 2, 4, 6]

max：获取对象数组中指定标识符最大的项

使用说明
- 参数：目标对象数组、指定标识符的回调函数。
- 返回值：符合条件的对象。

使用代码示例

import { max } from 'radash'

const 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"}

merge：合并数组中符合条件的项，并且会覆盖第一个数组

使用说明
- 参数：数组1、数组2、条件函数。
- 返回值：合并覆盖后的数组。

使用代码示例

import { merge } from 'radash'

const 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}]

min：获取对象数组中指定标识符最小的项

使用说明
- 参数：目标对象数组、指定标识符的条件函数。
- 返回值：符合条件的的项。

使用代码示例

import { min } from 'radash'

const 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"}

objectify：根据函数映射的键与值把数组转换为字典对象

使用说明
- 参数：目标对象数组、条件函数1用于提取键、[条件函数2用于提取值]
- 返回值：字典对象。

使用代码示例

import { objectify } from 'radash'

const fish = [
  {
    name: 'Marlin',
    weight: 105
  },
  {
    name: 'Bass',
    weight: 8
  },
  {
    name: 'Trout',
    weight: 13
  }
]

objectify(fish, f => f.name) // => { Marlin: [marlin object], Bass: [bass object], ... }
objectify(
  fish,
  f => f.name,
  f => f.weight
) // => { Marlin: 105, Bass: 8, Trout: 13 }

range：根据步长生成一个数值范围内的迭代值

使用说明
- 参数：起始值、[结束值]、[迭代函数]、步长。
- 返回值：用在for循环中循环输出处理的结果值。

使用代码示例

import { range } from 'radash'

range(3)                  // yields 0, 1, 2, 3
range(0, 3)               // yields 0, 1, 2, 3
range(0, 3, 'y')          // yields y, y, y, y
range(0, 3, () => 'y')    // yields y, y, y, y
range(0, 3, i => i)       // yields 0, 1, 2, 3
range(0, 3, i => `y${i}`) // yields y0, y1, y2, y3
range(0, 3, obj)          // yields obj, obj, obj, obj
range(0, 6, i => i, 2)    // yields 0, 2, 4, 6

for (const i of range(0, 200, 10)) {
  console.log(i) // => 0, 10, 20, 30 ... 190, 200
}

for (const i of range(0, 5)) {
  console.log(i) // => 0, 1, 2, 3, 4, 5
}

replaceOrAppend：替换对象数组中的项或是追加项（条件函数不满足时追加）

使用说明
- 参数：被替换数组、用来的替换的数组、条件函数。
- 返回值：替换或者追加后的数组。

使用代码示例

import { replaceOrAppend } from 'radash'

const fish = [
  {
    name: 'Marlin',
    weight: 105
  },
  {
    name: 'Salmon',
    weight: 19
  },
  {
    name: 'Trout',
    weight: 13
  }
]

const salmon = {
  name: 'Salmon',
  weight: 22
}

const sockeye = {
  name: 'Sockeye',
  weight: 8
}

replaceOrAppend(fish, salmon, f => f.name === 'Salmon') // => [marlin, salmon (weight:22), trout]
replaceOrAppend(fish, sockeye, f => f.name === 'Sockeye') // => [marlin, salmon, trout, sockeye]

replace ：查找指定项，并用传入的去替换

使用说明
- 参数：对象数组1、用于替换的对象、条件函数。
- 返回值：替换目标项后的原始数组副本（新数组）。

使用代码示例

import { replace } from 'radash'

const 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') // => [marlin, salmon, trout]

select ：对数组同时进行过滤和映射，筛选和转换数组中的元素

使用说明
- 参数：对象数组、映射条件函数、过滤条件函数。
- 返回值：过滤完后的映射值组成的数组。

使用代码示例

import { select } from 'radash'

const fish = [
  {
    name: 'Marlin',
    weight: 105,
    source: 'ocean'
  },
  {
    name: 'Bass',
    weight: 8,
    source: 'lake'
  },
  {
    name: 'Trout',
    weight: 13,
    source: 'lake'
  }
]

select(
  fish,
  f => f.weight,
  f => f.source === 'lake'
) // => [8, 13]

shift ：把目标数组向右循环移动 n 个位置返回为一个新数组

使用说明
- 参数：目标数组、移动步数。
- 返回值：移动后的新数组。

使用代码示例

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]

sift：过滤调列表中值为false的项，返回剩余为true的项组成的数组

使用说明
- 参数：数组。
- 返回值：过滤后的新数组。

使用代码示例

import { sift } from 'radash'

const fish = ['salmon', null, false, NaN, 'sockeye', 'bass']

sift(fish) // => ['salmon', 'sockeye', 'bass']

sort ：把数组按照条件函数指定的项的数值大小排序，支持升序和降序

使用说明
- 参数：对象数组、指定标识符的条件函数、是否降序（Boolean值，不传为false）。
- 返回值：排序后的数组。

使用代码示例

import { sort } from 'radash'

const 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]

sum：数组对象根据条件函数指定想的数组求和

使用说明
- 参数：对象数组、指定标识符的条件函数。
- 返回值：符合条件的项的和。

使用代码示例

import { sum } from 'radash'

const fish = [
  {
    name: 'Marlin',
    weight: 100
  },
  {
    name: 'Bass',
    weight: 10
  },
  {
    name: 'Trout',
    weight: 15
  }
]

sum(fish, f => f.weight) // => 125

toggle：查找数组中是否有我们给定的项，有则删除，没有则添加

使用说明
- 参数：目标数组、条件值（可以是条件函数）、在前面添加还是在后边添加。
- 返回值：处理后的新数组。

使用代码示例

import { toggle } from 'radash'

// 基本用法
const gods = ['ra', 'zeus', 'loki']

toggle(gods, 'ra')     // => [zeus, loki]
toggle(gods, 'vishnu') // => [ra, zeus, loki, vishnu]


// 切换（数组、条件项、指定标识符的条件函数）
import { toggle } from 'radash'

const ra = { name: 'Ra' }
const zeus = { name: 'Zeus' }
const loki = { name: 'Loki' }
const vishnu = { name: 'Vishnu' }

const gods = [ra, zeus, loki]

toggle(gods, ra, g => g.name)     // => [zeus, loki]
toggle(gods, vishnu, g => g.name) // => [ra, zeus, loki, vishnu]


// 切换（数组、条件项、条件函数，覆盖项）
import { toggle } from 'radash'

const gods = ['ra', 'zeus', 'loki']

toggle(gods, 'vishnu', g => g, { strategy: 'prepend' }) // => [vishnu, ra, zeus, loki]

unique：数组去重，去除数组中重复的项

使用说明
- 参数：目标数组、指定唯一标识符的条件函数。
- 返回值：去重后的数组。

使用代码示例

import { unique } from 'radash'

const 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' }
// ]

zipToObject：将第一个数组中的键映射到第二个数组中对应的值

使用说明
- 参数：数组1、数组2（或者是传入一个函数）。
- 返回值：映射后的对象。

使用代码示例

import { zipToObject } from 'radash'

const 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 }

zip：把两个数组变为二维数组，二维数组中的每个数组包含两个项分别为两个传入数组的相同位置的项

使用说明
- 参数：数组1、数组2。
- 返回值：映射后的二维数组。

使用代码示例

import { zip } from 'radash'

const names = ['ra', 'zeus', 'loki']
const cultures = ['egypt', 'greek', 'norse']

zip(names, cultures)
// => [
//   [ra, egypt]
//   [zeus, greek]
//   [loki, norse]
// ]

对象方法

assign：递归合并两个对象

使用说明
- 功能说明：类似于 JavaScript 的 Object.assign 方法，用于将 override 对象的属性和值复制到 initial 对象中。如果属性值是对象，则递归地进行赋值。
- 参数：初始对象、覆盖对象。
- 返回值：返回合并后的新对象

使用代码示例

import { assign } from 'radash'

const ra = {
  name: 'Ra',
  power: 100
}

assign(ra, { name: 'Loki' })
// => { name: Loki, power: 100 }

clone：浅拷贝对象

使用说明
- 功能说明：这个函数接受一个对象 obj 作为参数，并返回这个对象的一个新的浅拷贝。
- 参数：需要克隆的对象。
- 返回值：过滤完后的映射值组成的数组。

使用代码示例

import { clone } from 'radash'

const ra = {
  name: 'Ra',
  power: 100
}

const gods = [ra]

clone(ra) // => copy of ra
clone(gods) // => copy of gods

construct：把扁平对象构建为深层对象（多维）

使用说明
- 功能说明：这个函数接受一个对象 obj 作为参数，并返回这个对象的一个新的浅拷贝。
- 参数：键值对对象。
- 返回值：构建后的新对象。

使用代码示例

import { construct } from 'radash'

const flat = {
  name: 'ra',
  power: 100,
  'friend.name': 'loki',
  'friend.power': 80,
  'enemies.0.name': 'hathor',
  'enemies.0.power': 12
}

construct(flat)
// {
//   name: 'ra',
//   power: 100,
//   friend: {
//     name: 'loki',
//     power: 80
//   },
//   enemies: [
//     {
//       name: 'hathor',
//       power: 12
//     }
//   ]
// }

crush：把深层（多维）对象构建成扁平对象（construct的相反操作）

使用说明
- 功能说明：这个函数接受一个对象 obj 作为参数，并返回这个对象的一个新的浅拷贝。
- 参数：对象。
- 返回值：构建后的扁平数组。

使用代码示例

import { crush } from 'radash'

const ra = {
  name: 'ra',
  power: 100,
  friend: {
    name: 'loki',
    power: 80
  },
  enemies: [
    {
      name: 'hathor',
      power: 12
    }
  ]
}

crush(ra)
// {
//   name: 'ra',
//   power: 100,
//   'friend.name': 'loki',
//   'friend.power': 80,
//   'enemies.0.name': 'hathor',
//   'enemies.0.power': 12
// }

get：获取对象中的任意属性，可以通过 `.` 的方式获取深层的属性

使用说明
- 功能说明：用于安全地访问嵌套对象的属性，即使某些中间属性不存在也不会抛出错误。如果找不到指定的路径，则返回一个默认值。
- 参数：目标对象、属性字符（可以.表示深层次属性）、默认值。
- 返回值：找到则返回指定值，否则返回默认值。

使用代码示例

import { get } from 'radash'

const fish = {
  name: 'Bass',
  weight: 8,
  sizes: [
    {
      maturity: 'adult',
      range: [7, 18],
      unit: 'inches'
    }
  ]
}

get( fish, 'sizes[0].range[1]' ) // 18
get( fish, 'sizes.0.range.1' ) // 18
get( fish, 'foo', 'default' ) // 'default'

invert：把对象中的`key`和`value`对调

使用说明
- 功能说明：用于反转对象的键和值。这意味着原始对象的键成为新对象的值，原始对象的值成为新对象的键。
- 参数：需要反转的对象。
- 返回值：反转后的新数组。

使用代码示例

import { invert } from 'radash'

const powersByGod = {
  ra: 'sun',
  loki: 'tricks',
  zeus: 'lighning'
}

invert(gods) // => { sun: ra, tricks: loki, lightning: zeus }

keys：获取对象中所有的`key`，包括深层的（表示成a.b的形式）

使用说明
- 功能说明：于获取一个对象的所有嵌套属性键的完整路径。这些路径用点号连接，表示从根到叶子的完整路径。
- 参数：目标对象。
- 返回值：过滤完后的映射值组成的数组。

使用代码示例

import { keys } from 'radash'

const 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'
// ]

listify：把对象的键值对转换成一个由特定结构元素组成的数组

使用说明
- 功能说明：用于将一个对象的键值对转换成一个由特定结构元素组成的数组。这个函数接受两个参数：一个对象 obj 和一个转换函数 toItem。toItem 函数接受对象的每个键和对应的值，并返回一个新的元素。
- 参数：目标对象、条件函数。
- 返回值：构建后的结果数组。

使用代码示例

import { listify } from 'radash'

const fish = {
  marlin: {
    weight: 105,
  },
  bass: {
    weight: 8,
  }
}

listify(fish, (key, value) => ({ ...value, name: key })) // => [{ name: 'marlin', weight: 105 }, { name: 'bass', weight: 8 }]

lowerize：将对象的所有`key`转换为小写形式

使用说明
- 功能说明：用于将一个对象的所有键转换为小写形式，内部用到mapKeys，而 mapKeys 函数则用于一般性地将一个对象的键通过一个映射函数转换为新的键。
- 参数：对象、映射函数。
- 返回值：返回一个键是小写形式的对象。

使用代码示例

import { lowerize } from 'radash'

const ra = {
  Mode: 'god',
  Power: 'sun'
}

lowerize(ra) // => { mode, power }

upperize：将对象的所有`key`转换为大写形式

使用说明
- 功能说明：用于将一个对象的所有键转换为大写形式，而 mapKeys 函数则用于一般性地将一个对象的键通过一个映射函数 mapFunc 转换为新的键。
- 参数：目标对象、映射函数。
- 返回值：转换后的新对象。

使用代码示例

import { upperize } from 'radash'

const ra = {
  Mode: 'god',
  Power: 'sun'
}

upperize(ra) // => { MODE, POWER }

mapEntries：将对象的键值对通过一个转换函数映射为新的对象

使用说明
- 功能说明：用于将一个对象的键值对通过一个转换函数 toEntry 映射为新的键值对，并创建一个新的对象。这个函数接受两个参数：一个对象 obj 和一个转换函数 toEntry。toEntry 函数接受对象的每个键和对应的值，并返回一个包含新键和新值的元组。
- 参数：目标对象、转换函数。
- 返回值：构建完成的结果对象。

使用代码示例

import { mapEntries } from 'radash'

const ra = {
  name: 'Ra',
  power: 'sun',
  rank: 100,
  culture: 'egypt'
}

mapEntries(ra, (key, value) => [key.toUpperCase(), `${value}`]) // => { NAME: 'Ra', POWER: 'sun', RANK: '100', CULTURE: 'egypt' }

mapKeys：把对象的`kye`通过一个映射函数转换为新的`key`

使用说明
- 功能说明：将一个对象的键通过一个映射函数 mapFunc 转换为新的键，并创建一个新对象。这个函数接受两个参数：一个对象 obj 和一个映射函数 mapFunc。mapFunc 函数接受对象的每个键和对应的值，并返回一个新的键。
- 参数：目标对象、映射函数。
- 返回值：构建完成的新对象。

使用代码示例

import { mapKeys } from 'radash'

const ra = {
  mode: 'god',
  power: 'sun'
}

mapKeys(ra, key => key.toUpperCase()) // => { MODE, POWER }
mapKeys(ra, (key, value) => value) // => { god: 'god', power: 'power' }

mapValues：对象的`value`通过一个映射函数转换为新的`value`

使用说明
- 功能说明：将一个对象的值通过一个映射函数 mapFunc 转换为新的值，并创建一个新对象。这个函数接受两个参数：一个对象 obj 和一个映射函数 mapFunc。mapFunc 函数接受对象的每个值和对应的键，并返回一个新的值。
- 参数：目标对象、映射函数。
- 返回值：构建完成的新对象。

使用代码示例

import { mapValues } from 'radash'

const ra = {
  mode: 'god',
  power: 'sun'
}

mapValues(ra, value => value.toUpperCase()) // => { mode: 'GOD', power: 'SUN' }
mapValues(ra, (value, key) => key) // => { mode: 'mode', power: 'power' }

omit：创建一个省略了 `keys` 数组中指定的一些键的新对象

使用说明
- 功能说明：创建一个新的对象，该对象是原始对象 obj 的副本，但省略了 keys 数组中指定的一些键。这个函数接受两个参数：一个对象 obj 和一个包含要省略键名的数组 keys。
- 参数：目标对象、要省略的key数组。
- 返回值：省略了指定键的新对象。

使用代码示例

import { omit } from 'radash'

const fish = {
  name: 'Bass',
  weight: 8,
  source: 'lake',
  brackish: false
}

omit(fish, ['name', 'source']) // => { weight, brackish }

pick：创建一个只包含原始对象中指定的 `keys`的对象

使用说明
- 功能说明：创建一个新的对象，该对象只包含原始对象 obj 中指定的 keys。这个函数接受两个参数：一个对象 obj 和一个包含要选择键名的数组 keys。
- 参数：目标对象、需要包含的key的数组
- 返回值：过滤完后的映射值组成的数组。

使用代码示例

import { pick } from 'radash'

const fish = {
  name: 'Bass',
  weight: 8,
  source: 'lake',
  barckish: false
}

pick(fish, ['name', 'source']) // => { name, source }

set：在一个对象中设置一个由点或方括号表示法指定的路径上的值

使用说明
- 功能说明：用于在一个对象中设置一个值，该值位于由点或方括号表示法指定的路径上。如果路径中的任何中间对象不存在，set 函数将创建它们。
- 参数：初始对象、属性路径字符串、设置值。

使用代码示例

import { set } from 'radash'

set({}, 'name', 'ra')
// => { name: 'ra' }

set({}, 'cards[0].value', 2)
// => { cards: [{ value: 2 }] }

shake：过滤对象

使用说明
- 功能说明：创建一个新的对象，该对象是原始对象 obj 的副本，但省略了那些经过 filter 函数检查并返回 true 的属性。filter 函数默认会过滤掉值为 undefined 的属性。
- 参数：目标对象、[过滤函数]。
- 返回值：过滤完后的映射值组成的数组。

使用代码示例

import { shake } from 'radash'

const ra = {
  mode: 'god',
  greek: false,
  limit: undefined
}

shake(ra) // => { mode, greek }
shake(ra, a => !a) // => { mode }

函数柯里化

chain：创建一个函数链并依次执行

使用说明
1. 功能描述：用于创建一个函数链，该链依次执行一系列函数，每个函数的输出都是下一个函数的输入。这种模式常见于函数式编程，特别是在数据转换和流水线处理中。
2. 参数：函数数组（或者说任意数量的函数）。
3. 返回值：返回一个新的函数。

使用代码示例

import { chain } from 'radash'

const add = (y: number) => (x: number) => x + y
const mult = (y: number) => (x: number) => x * y
const addFive = add(5)
const double = mult(2)

const chained = chain(addFive, double)

chained(0) // => 10
chained(7) // => 24

compose：依次执行传入的函数，每个函数的输出作为下一个函数的输入

使用说明
1. 功能描述：接受一系列函数作为参数，并返回一个新的函数。这个新函数将从右到左依次执行传入的函数，每个函数的输出作为下一个函数的输入。这是函数式编程中的组合（composition）模式。
2. 参数：一系列函数（函数数组）。
3. 返回值：一个新的函数。

使用代码示例

import { compose } from 'radash'

const useZero = (fn: any) => () => fn(0)
const objectize = (fn: any) => (num: any) => fn({ num })
const increment = (fn: any) => ({ num }: any) => fn({ num: num + 1 })
const returnArg = (arg: any) => (args: any) => args[arg]

const composed = compose(
  useZero,
  objectize,
  increment,
  increment,
  returnArg('num')
)

composed() // => 2

debounce ：函数防抖

使用说明
1. 功能描述：创建一个防抖函数，该函数会在指定的延迟时间后执行。防抖（debouncing）是一种控制函数执行频率的技术，它确保函数只在最后一次被调用后的一段时间后执行，通常用于处理像窗口调整大小或键盘输入这样的连续事件。
2. 参数：配置对象（包含delay——延时）、需要防抖的函数。
3. 返回值：返回防抖后的函数。

使用代码示例

import { debounce } from 'radash'

const makeSearchRequest = (event) => {
  api.movies.search(event.target.value)
}

input.addEventListener('change', debounce({ delay: 100 }, makeSearchRequest))

throttle ：函数节流

使用说明
1. 功能描述：节流（Throttling）是一种控制函数调用频率的技术，它确保函数在指定的时间间隔内最多只执行一次。这通常用于限制频繁触发的事件（如窗口调整大小、滚动等）的处理函数。
2. 参数：对象（{interval}）—— 触发间隔、需要节流的函数。
3. 返回值：返回节流后的函数。

使用代码示例：

import { throttle } from 'radash'

const onMouseMove = () => {
  rerender()
}

addEventListener('mousemove', throttle({ interval: 200 }, onMouseMove))

memo：创建一个记忆化（memoized）版本的给定函数

使用说明
1. 功能描述：记忆化是一种优化技术，它存储函数执行的结果，并在后续调用中重用这个结果，以避免重复执行相同计算。这种技术特别适用于计算成本高昂或调用频繁的函数。
2. 参数：需要被记忆化的函数、可选配置对象。
3. 返回值：返回一个记忆版本的函数。

使用代码示例

import { memo } from 'radash'

const timestamp = memo(() => Date.now())

const now = timestamp()
const later = timestamp()

now === later // => true

partial ：创建一个偏应用的部分函数（允许你预先填充一些参数，只需传入剩余参数）

使用说明
1. 功能描述：创建一个新函数，这个新函数是原始函数 fn 的偏应用版本。偏应用（Partial Application）是一种函数式编程技术，它允许你预先填充一些参数，并返回一个新函数，这个新函数只需要剩余的参数就可以执行。
2. 参数：原始函数，原始参数数组。
3. 返回值：返回一个接受剩余的参数数组 rest的新函数。

使用代码示例

import { partial } from 'radash'

const add = (a: number, b: number) => a + b

const addFive = partial(add, 5)

addFive(2) // => 7

partob：创建一个偏应用的部分函数（跟partial类似，不过接收参数不一样）

使用说明
1. 功能描述：创建一个新的函数，该函数是原始函数 fn 的偏应用版本。这个新函数将接受一个对象参数 restobj，它包含了原始函数 fn 所需参数的剩余部分，然后将 restobj 与预先填充的参数对象 argobj 合并后调用 fn。
2. 参数：原始函数、预先填充的参数对象。
3. 返回值：返回一个接收剩余参数对象 restobj的新函数。

使用代码示例

import { partob } from 'radash'

const add = (props: { a: number; b: number }) => props.a + props.b

const addFive = partob(add, { a: 5 })

addFive({ b: 2 }) // => 7

proxied：创建动态代理对象

使用说明
1. 功能描述：创建的代理对象可以拦截对其属性的访问并返回由一个处理函数 handler 产生的值。
2. 参数：处理函数（该函数接受一个属性名）。
3. 返回值：返回一个新的 Proxy 对象。

使用代码示例

import { proxied } from 'radash'

type Property = 'name' | 'size' | 'getLocation'

const person = proxied((prop: Property) => {
  switch (prop) {
    case 'name':
      return 'Joe'
    case 'size':
      return 20
    case 'getLocation'
      return () => 'here'
  }
})

person.name // => Joe
person.size // => 20
person.getLocation() // => here

Number相关

inRange ：检查给定数字是否在两个数字之间

使用说明
1. 功能描述：检查给定数字是否在两个数字之间。判断包含起始值。不包含结束值。范围的开始和结束可以是升序或降序。如果未指定结束值，则将其设置为起始值。并且把起始值设置为0。
2. 参数：需要检查的值，判断的起始值，[判断的结束值]。
3. 返回值：在范围内返回 true，否则返回 false。

使用代码示例

import { inRange } from 'radash'

inRange(10, 0, 20) // true
inRange(9.99, 0, 10) // true
inRange(Math.PI, 0, 3.15) // true
inRange(10, 10, 20) // true
inRange(10, 0, 10) // false

inRange(1, 2) // true
inRange(1, 0) // false

toFloat ：可能的情况下，将一个值转为浮点值

使用说明
1. 功能描述：将一个值转换为浮点数。如果转换失败或者提供的值是 null 或 undefined，函数将返回默认值。
2. 参数：需要转换的值、默认值。
3. 返回值：能转换则返回转换后的浮点数，否则返回传入的默认值。

使用代码示例

import { toFloat } from 'radash'

toFloat(0) // => 0.0
toFloat(null) // => 0.0
toFloat(null, 3.33) // => 3.33

toInt：可能的情况下，将一个值转为整数

使用说明
1. 功能描述：将一个值转换为整数。如果转换失败或者提供的值是 null 或 undefined，函数将返回默认值。
2. 参数：需要转换的值、默认值。
3. 返回值：能转换则返回转换后的整数，否则返回传入的默认值。

使用代码示例

import { toInt } from 'radash'

toInt(0) // => 0
toInt(null) // => 0
toInt(null, 3) // => 3

随机方法

draw：取出数组中的随机项

使用说明
- 功能说明：从一个数组中随机抽取一个元素。如果数组为空，则返回 null。
- 参数：数组。
- 返回值：数组中的随机项。

使用代码示例

import { draw } from 'radash'

const fish = ['marlin', 'bass', 'trout']

draw(fish) // => a random fish

random：生成一个随机数

使用说明
- 功能说明：生成一个指定范围内的随机整数。包含最大值和最小值。
- 参数：最大值、最小值
- 返回值：返回一个范围内的随机整数。

使用代码示例

import { random } from 'radash'

random(0, 100) // => a random number between 0 and 100

shuffle：随机打乱数组的顺序

使用说明
- 功能说明：这个函数用于打乱（洗牌）一个数组中元素的顺序。
- 参数：需要打乱的数组。
- 返回值：打乱后的数组。

使用代码示例

import { shuffle } from 'radash'

const fish = [
  {
    name: 'Marlin',
    weight: 105,
    source: 'ocean'
  },
  {
    name: 'Salmon',
    weight: 22,
    source: 'river'
  },
  {
    name: 'Salmon',
    weight: 22,
    source: 'river'
  }
]

shuffle(fish)

uid：生成一个指定长度的随机标识符

使用说明
- 功能说明：用于生成一个指定长度的随机字符串，该字符串由大写字母、小写字母、数字以及可选的特殊字符组成。
- 参数：长度、可选的随机标识符。
- 返回值：生成的随机字符串。

使用代码示例

import { uid } from 'radash'

uid(7) // => UaOKdlW
uid(20, '*') // => dyJdbC*NsEgcnGjTHS

series：创建一个有序的序列对象

使用说明
- 功能说明：用于创建一个对象，该对象提供多种操作传入的 items 数组的方法。这些方法包括获取最小/最大元素、第一个/最后一个元素、下一个/前一个元素以及旋转数组中元素的位置。
- 参数：数组、映射函数。
- 返回值：返回一个包含多个方法的对象。

使用代码示例

import { series } from 'radash'

type Weekday = 'monday' | 'tuesday' | 'wednesday' | 'thursday' | 'friday'

const weekdays = series<Weekday>([
  'monday',
  'tuesday',
  'wednesday',
  'thursday',
  'friday'
])

weekdays.min('tuesday', 'thursday') // => 'tuesday'
weekdays.max('wednesday', 'monday') // => 'wednesday'
weekdays.next('wednesday') // => 'thursday'
weekdays.previous('tuesday') // => 'monday'
weekdays.first() // => 'monday'
weekdays.last() // => 'friday'
weekdays.next('friday') // => null
weekdays.next('friday', weekdays.first()) // => 'monday'
weekdays.spin('monday', 3) // => 'thursday'

字符串方法

camel：将字符串转为小驼峰格式

使用说明
- 功能说明：用于将输入的字符串 str 转换为驼峰命名法（camelCase）。这个函数首先将字符串中的所有大写字母转换为小写，并在每个大写字母前添加一个空格，然后根据大写字母、点号、破折号、空格或下划线分割字符串，最后将分割出的字符串数组转换为驼峰式。
- 参数：字符串str。
- 返回值：转换后的字符串。

使用代码示例

import { camel } from 'radash'

camel('green fish blue fish') // => greenFishBlueFish

pascal：将字符串转为大驼峰命名的格式

使用说明
- 功能说明：用于将输入字符串 str 转换为帕斯卡命名法（PascalCase），即每个单词的首字母大写，其余字母小写，且单词之间没有分隔符。如果输入字符串为空或长度为0，则返回空字符串。
- 参数：需要处理的字符串。
- 返回值：处理后的大驼峰命名法的字符串。

使用代码示例

import { pascal } from 'radash'

pascal('hello world') // => 'HelloWorld'
pascal('va va boom') // => 'VaVaBoom'

capitalize：将字符串首字母转为大写

使用说明
- 功能说明：于将输入字符串 str 的首字母大写，其余字母小写。如果输入字符串为空或长度为0，则返回空字符串。
- 参数：需要处理的字符串。
- 返回值：处理后的字符串。

使用代码示例

import { capitalize } from 'radash'

capitalize('green fish blue FISH') // => Green fish blue fish

dash：把字符串转为短横线（-）分隔并且全小写的格式

使用说明
- 功能说明：用于将输入字符串 str 转换为短横线命名法（kebab-case）。这个函数首先将字符串中的所有大写字母转换为小写，并在每个大写字母前添加一个短横线，然后根据大写字母、点号、破折号、空格或下划线分割字符串，最后将分割出的字符串数组转换为短横线命名法。
- 参数：需要处理的字符串。
- 返回值：组合后的短横线命名法字符串。

使用代码示例

import { dash } from 'radash'

dash('green fish blue fish') // => green-fish-blue-fish

snake：将字符串转换为下划线格式

使用说明
- 功能说明：用于将输入字符串 str 转换为蛇形命名法（snake_case）。这个函数接受一个字符串和一个可选的 options 对象作为参数，options 对象中的 splitOnNumber 属性用于指定是否在字母和紧随其后的数字之间添加下划线。
- 参数：需要处理的字符串、配置对象（可选）。
- 返回值：处理后的字符串。

使用代码示例

import { snake } from 'radash'

snake('green fish blue fish') // => green_fish_blue_fish

snake('5green fish 2blue fish') // => 5_green_fish_2_blue_fish

snake('5green fish 2blue fish', {
    splitOnNumber: false
}) // => 5green_fish_2blue_fish

template：在字符串中使用模板变量

使用说明
- 功能说明：用于根据提供的数据对象 data 替换字符串 str 中的模板占位符。函数接受三个参数：一个字符串 str，一个数据对象 data，以及一个可选的正则表达式 regex 用于匹配模板占位符。
- 参数：字符串、要替换占位符的键值对对象。
- 返回值：替换后的字符串。

使用代码示例

import { template } from 'radash'

template('It is {{color}}', { color: 'blue' }) // => It is blue
template('It is <color>', { color: 'blue' }, /<(.+?)>/g) // => It is blue

title：将字符串转换为首字母大写格式

使用说明
- 功能说明：用于将输入字符串 str 转换为标题格式（Title Case），其中每个单词的首字母大写，其余字母小写，单词之间用空格分隔。如果输入字符串为空、null 或 undefined，则返回空字符串。
- 参数：字符串（可能为null、undefined)。
- 返回值：处理后的字符串。

使用代码示例

import { title } from 'radash'

title('hello world') // => 'Hello World'
title('va_va_boom') // => 'Va Va Boom'
title('root-hook') // => 'Root Hook'
title('queryItems') // => 'Query Items'

trim：去除字符串首尾的指定字符

使用说明
- 功能说明：用于从字符串的开头和结尾去除指定的字符。如果输入字符串为空、null 或 undefined，则返回空字符串。charsToTrim 参数指定了要去除的字符，默认为去除空格。
- 参数：需要处理的字符串、需要删除的字符。
- 返回值：处理后的字符串。

使用代码示例

import { trim } from 'radash'

trim('  hello ') // => hello
trim('__hello__', '_') // => hello
trim('/repos/:owner/', '/') // => repos/:owner

异步方法

all：同时执行多个异步操作

使用说明
1. 功能描述：类似于 Promise.all 和 Promise.allSettled，等待一个由多个 Promise 组成的对象或数组中的所有 Promise 都完成（或者其中一个失败）。执行的所有错误和抛出的错误都会收集在 AggregateError 中。
2. 参数：promise对象/promise数组
3. 返回值：所有 promise 执行后的结果数组或对象

使用代码示例

import { all } from 'radash'

// 传入promise数组
const [user] = await all([
  api.users.create(...),
  s3.buckets.create(...),
  slack.customerSuccessChannel.sendMessage(...)
])

// 传入对象
const { user } = await all({
  user: api.users.create(...),
  bucket: s3.buckets.create(...),
  message: slack.customerSuccessChannel.sendMessage(...)
})

defer：在异步流程中添加清理或错误处理逻辑

使用说明
1. 功能描述：用来执行一个异步函数，同时提供注册回调的机制，在异步函数执行完成后执行特定回调操作。
2. 参数：异步函数。
3. 返回值：异步函数成功执行时，返回其响应结果，否则重新抛出错误。

使用代码示例

import { defer } from 'radash'

await defer(async (cleanup) => {
  const buildDir = await createBuildDir()

  cleanup(() => fs.unlink(buildDir))

  await build()
})

await defer(async (register) => {
  const org = await api.org.create()
  register(async () => api.org.delete(org.id), { rethrow: true })

  const user = await api.user.create()
  register(async () => api.users.delete(user.id), { rethrow: true })

  await executeTest(org, user)
})

guard：执行一个函数，并提供错误处理的能力

使用说明
1. 功能描述：guard 函数可以用来为函数调用提供额外的错误处理逻辑，特别是当你希望根据错误类型选择性地处理错误时。
2. 参数：目标函数、指定错误对象得函数（可选）。
3. 返回值：抛出原始或返回undefined。

使用代码示例

import { guard } from 'radash'

const users = (await guard(fetchUsers)) ?? []

const isInvalidUserError = (err: any) => err.code === 'INVALID_ID'
const user = (await guard(fetchUser, isInvalidUserError)) ?? DEFAULT_USER

map：对一个数组中的每个元素执行一个异步映射函数

使用说明
1. 功能描述：它用于对一个数组中的每个元素执行一个异步映射函数，并返回一个包含所有映射结果的新数组。这个函数是 Array.prototype.map 方法的异步版本。
2. 参数：数组，异步函数。
3. 返回值：映射后的新数组。

使用代码示例

import { map } from 'radash'

const userIds = [1, 2, 3, 4]

const users = await map(userIds, async (userId) => {
  return await api.users.find(userId)
})

parallel：并行地处理数组中的元素，并对每个元素执行一个异步函数

使用说明
1. 功能描述：这个函数会限制同时进行的异步操作的数量，以避免同时启动过多的异步任务。
2. 参数：限制数量（number）、需要被异步处理的元素数组、转换函数（将数组中的每个元素转换为一个异步操作）。
3. 返回值：返回一个数组，该数组包含了按原数组顺序排序的所有成功的结果。

使用代码示例

import { parallel } from 'radash'

const userIds = [1, 2, 3, 4, 5, 6, 7, 8, 9]

// Will run the find user async function 3 at a time
// starting another request when one of the 3 is freed
const users = await parallel(3, userIds, async (userId) => {
  return await api.users.find(userId)
})


const userIds = [1, 2, 3]

const [err, users] = await tryit(parallel)(3, userIds, async (userId) => {
  throw new Error(`No, I don\'t want to find user ${userId}`)
})

console.log(err) // => AggregateError
console.log(err.errors) // => [Error, Error, Error]
console.log(err.errors[1].message) // => No, I don't want to find user 2

reduce：对数组中的每个元素执行一个异步归约函数

使用说明
1. 功能描述：它是 Array.prototype.reduce 方法的异步版本，用于对数组中的每个元素执行一个异步归约函数，并返回最终的归约值。
2. 参数：被归约处理的元素数组、异步归约函数。
3. 返回值：返回最终归约的值。

使用代码示例

import { reduce } from 'radash'

const userIds = [1, 2, 3, 4]

const users = await reduce(userIds, async (acc, userId) => {
  const user = await api.users.find(userId)
  return {
    ...acc,
    [userId]: user
  }
}, {})

retry：反复尝试执行一个异步操作，直到达到设置上限

使用说明
1. 功能描述：用于反复尝试执行一个异步操作，直到成功或达到重试次数上限。如果操作失败，可以选择在重试之间设置延迟或使用退避函数（backoff）来计算延迟时间。
2. 参数：条件对象options（包含：重复次数、延迟、退避函数）、失败执行的异步操作函数。
3. 返回值：可能发挥undefined。

使用代码示例

import { retry } from 'radash'

await retry({}, api.users.list)
await retry({ times: 10 }, api.users.list)
await retry({ times: 2, delay: 1000 }, api.users.list)

// exponential backoff
await retry({ backoff: i => 10**i }, api.users.list)

sleep：提供一个延时机制

使用说明
1. 功能描述：提供一个延时机制，通常用于异步操作中的暂停。
2. 参数：暂停时间（ms）。
3. 返回值：返回一个新的Promise。

使用代码示例

import { sleep } from 'radash'

await sleep(2000) // => waits 2 seconds

tryit：捕获函数在执行过程中可能抛出的同步或异步错误

使用说明
1. 功能描述：tryit 是一个高阶函数。用于捕获函数在执行过程中可能抛出的同步或异步错误，并返回一个元组，其中包含错误对象或函数的返回值。这个函数的目的是提供一种安全执行任意函数并处理错误的方式。
2. 参数：需要被捕获的函数。
3. 返回值：返回一个新函数，该函数接收与传入函数相同的参数。

使用代码示例

import { tryit } from 'radash'

const findUser = tryit(api.users.find)

const [err, user] = await findUser(userId)

判断方法

isArray：判断某个值是否为数组

使用说明
- 功能说明：跟 Array.isArray() 方法功能一致。
- 参数：需要判断的值。
- 返回值：是数组返回 true, 否则返回 false。

使用代码示例

import { isArray } from 'radash'

isArray('hello') // => false
isArray(['hello']) // => true

isDate：判断某个值是否为日期对象

使用说明
- 参数：需要判断的值。
- 返回值：是日期返回 true, 否则返回 false。

使用代码示例

import { isDate } from 'radash'

isDate(new Date()) // => true
isDate(12)         // => false
isDate('hello')    // => false

isEmpty：判断一个值是否为空

使用说明
- 功能说明：用于检查一个值是否为空。"空" 的定义取决于值的类型，对于不同的数据类型有不同的判断逻辑。
- 参数：需要判断的值。
- 返回值：为空返回true，否则返回false。

使用代码示例

import { isDate } from 'radash'

isDate(new Date()) // => true
isDate(12)         // => false
isDate('hello')    // => false

isEqual：判断两个值是否相等

使用说明
- 功能说明：用于深度比较两个值 x 和 y 是否相等。这个函数支持比较原始值、Date 对象、RegExp 对象以及普通对象。
- 参数：需要比较的两个值。
- 返回值：相等返回true，否则返回false。

使用代码示例

import { isEqual } from 'radash'

isEqual(null, null) // => true
isEqual([], [])     // => true

isEqual('hello', 'world') // => false
isEqual(22, 'abc')        // => false

isFloat：判断一个值是否为浮点数

使用说明
- 功能说明：用于检查一个值是否为浮点数。如果是浮点数，它返回 true；否则返回 false。这个函数依赖于一个未在代码中定义的 isNumber 函数，我们可以假设 isNumber 函数用于检查一个值是否为 number 类型。
- 参数：需要判断的值。
- 返回值：是 float 类型返回true，否则返回false。

使用代码示例

import { isFloat } from 'radash'

isFloat(12.233)  // => true
isFloat(12)      // => false
isFloat('hello') // => false

isFunction：判断一个值是否为函数

使用说明
- 功能说明：用于检查给定的值 value 是否为函数。如果是函数，它返回 true；否则返回 false。
- 参数：需要判断的值。
- 返回值：是函数返回true，否则返回false。

使用代码示例

import { isFunction } from 'radash'

isFunction('hello') // => false
isFunction(['hello']) // => false
isFunction(() => 'hello') // => true

isInt：判断一个值是否是整数

使用说明
- 功能说明：用于检查给定的值 value 是否为整数。如果是整数，它返回 true；否则返回 false。这个函数依赖于一个未在代码中定义的 isNumber 函数，我们可以假设 isNumber 函数用于检查一个值是否为 number 类型。
- 参数：需要判断的值。
- 返回值：是整数返回true，否则返回false。

使用代码示例

import { isInt } from 'radash'

isInt(12) // => true
isInt(12.233) // => false
isInt('hello') // => false

isNumber：判断一个值是否是数字

使用说明
- 功能说明：用于检查给定的值 value 是否为数字类型。如果是数字类型，它返回 true；否则返回 false。这个函数使用了 Number 构造函数来尝试将 value 转换为数字，然后与原始值进行比较。
- 参数：需要判断的值。
- 返回值：是数字返回true，否则返回false。

使用代码示例

import { isNumber } from 'radash'

isNumber('hello') // => false
isNumber(['hello']) // => false
isNumber(12) // => true

isObject：判断一个值是否为对象

使用说明
- 功能说明：用于检查给定的值 value 是否为普通对象（即直接由 Object 构造函数创建的对象）。如果是普通对象，它返回 true；否则返回 false。
- 参数：需要判断的值。
- 返回值：是对象返回true，否则返回false。

使用代码示例

import { isObject } from 'radash'

isObject('hello') // => false
isObject(['hello']) // => false
isObject(null) // => false
isObject({ say: 'hello' }) // => true

isPrimitive：判断一个值是否为原始值

使用说明
- 功能说明：用于检查给定的值 value 是否是原始值。原始值是指那些不是对象也不是函数的数据类型，包括 undefined、null、boolean、number、string 和 symbol。如果 value 是原始值，函数返回 true；否则返回 false。
- 参数：需要判断的值。
- 返回值：是原始值返回true，否则返回false。

使用代码示例

import { isPrimitive } from 'radash'

isPrimitive(22) // => true
isPrimitive('hello') // => true
isPrimitive(['hello']) // => false

isPromise：判断一个值是否为`Promise`

使用说明
- 功能说明：用于检查给定的值 value 是否是一个 Promise 对象。如果是 Promise 对象，它返回 true；否则返回 false。这个函数在检查时会考虑 value 是否存在、是否具有 then 属性，以及 then 属性是否是一个函数。
- 参数：需要确认的值。
- 返回值：是Promise返回true，否则返回false。

使用代码示例

import { isPromise } from 'radash'

isPromise('hello') // => false
isPromise(['hello']) // => false
isPromise(new Promise(res => res())) // => true

isString：判断一个值是否为字符串

使用说明
- 用于检查给定的值 value 是否为字符串。如果是字符串，它返回 true；否则返回 false。函数检查 value 的类型是否为 'string'，这包括了字符串字面量和字符串对象（通过 String 构造函数创建的字符串实例）。
- 参数：需要判断的值。
- 返回值：是字符串返回true，否则返回false。

使用代码示例

import { isString } from 'radash'

isString('hello') // => true
isString(['hello']) // => false

isSymbol：判断一个值是否为`Symbol`类型

使用说明
- 功能说明：用于检查给定的值 value 是否为 symbol 类型。如果是 symbol 类型，它返回 true；否则返回 false。
- 参数：需要判断的值。
- 返回值：是Symbol类型返回true，否则返回false。

使用代码示例

import { isSymbol } from 'radash'

isSymbol('hello') // => false
isSymbol(Symbol('hello')) // => true

最后

我相信能看到最后的都是帅气多金又想进步的~~~~人才。

如果你想查看其他 radash 所有方法的源码实现，可前往主页查看

大家有任何问题或见解，欢迎评论区留言交流和批评指正！！！

你的每一个收藏都是作者写作的动力！！！

posted @ 2024-06-14 18:12 山里看瓜阅读(119) 评论(0) 编辑收藏举报

刷新页面返回顶部

山里看瓜

radash库方法使用大纲（全）—— 包含所有方法思维导图

前言

数组方法：

alphabetical：把对象数组按照选定key的value的字母顺序排列

boil：找出对象数组中满足条件的对象

cluster：把一个数组尽量均匀的分成多个数组

counting：统计对象数组中每个唯一标识符的出现次数

diff：返回数组 1 中出现但是没在数组 2 中出现的项

first：获取数组第一项，不存在返回默认值

flat：数组扁平化 —— 把包含多个数组的数组转为一个数组（注意不会递归）

fork：按条件将数组拆分成两个数组，满足条件的一个，不满足条件的一个

group：根据条件函数指定的key构建一个统计对象，key为指定的key有哪些value，value为对应对象

intersects：判断两个数组是否有公共项，返回一个布尔值

iterate：把一个函数迭代执行指定次数

last：输出数组的最后一项，如果数组为空则输出传入的默认值

list：创建包含特定项的数组

max：获取对象数组中指定标识符最大的项

merge：合并数组中符合条件的项，并且会覆盖第一个数组

min：获取对象数组中指定标识符最小的项

objectify：根据函数映射的键与值把数组转换为字典对象

range：根据步长生成一个数值范围内的迭代值

replaceOrAppend：替换对象数组中的项或是追加项（条件函数不满足时追加）

replace ：查找指定项，并用传入的去替换

select ：对数组同时进行过滤和映射，筛选和转换数组中的元素

shift ：把目标数组向右循环移动 n 个位置返回为一个新数组

sift：过滤调列表中值为false的项，返回剩余为true的项组成的数组

sort ：把数组按照条件函数指定的项的数值大小排序，支持升序和降序

sum：数组对象根据条件函数指定想的数组求和

toggle：查找数组中是否有我们给定的项，有则删除，没有则添加

unique：数组去重，去除数组中重复的项

zipToObject：将第一个数组中的键映射到第二个数组中对应的值

zip：把两个数组变为二维数组，二维数组中的每个数组包含两个项分别为两个传入数组的相同位置的项

对象方法

assign：递归合并两个对象

clone：浅拷贝对象

construct：把扁平对象构建为深层对象（多维）

crush：把深层（多维）对象构建成扁平对象（construct的相反操作）

get：获取对象中的任意属性，可以通过 . 的方式获取深层的属性

invert：把对象中的key和value对调

keys：获取对象中所有的key，包括深层的（表示成a.b的形式）

listify：把对象的键值对转换成一个由特定结构元素组成的数组

lowerize：将对象的所有key转换为小写形式

upperize：将对象的所有key转换为大写形式

mapEntries：将对象的键值对通过一个转换函数映射为新的对象

mapKeys：把对象的kye通过一个映射函数转换为新的key

mapValues：对象的value通过一个映射函数转换为新的value

omit：创建一个省略了 keys 数组中指定的一些键的新对象

pick：创建一个只包含原始对象中指定的 keys的对象

set：在一个对象中设置一个由点或方括号表示法指定的路径上的值

shake：过滤对象

函数柯里化

chain：创建一个函数链并依次执行

compose：依次执行传入的函数，每个函数的输出作为下一个函数的输入

debounce ：函数防抖

throttle ：函数节流

memo：创建一个记忆化（memoized）版本的给定函数

partial ：创建一个偏应用的部分函数（允许你预先填充一些参数，只需传入剩余参数）

partob：创建一个偏应用的部分函数（跟partial类似，不过接收参数不一样）

proxied：创建动态代理对象

Number相关

inRange ：检查给定数字是否在两个数字之间

toFloat ：可能的情况下，将一个值转为浮点值

toInt：可能的情况下，将一个值转为整数

随机方法

draw：取出数组中的随机项

random：生成一个随机数

shuffle：随机打乱数组的顺序

uid：生成一个指定长度的随机标识符

series：创建一个有序的序列对象

字符串方法

camel：将字符串转为小驼峰格式

pascal：将字符串转为大驼峰命名的格式

capitalize：将字符串首字母转为大写

dash：把字符串转为短横线（-）分隔并且全小写的格式

snake：将字符串转换为下划线格式

template：在字符串中使用模板变量

title：将字符串转换为首字母大写格式

trim：去除字符串首尾的指定字符

异步方法

get：获取对象中的任意属性，可以通过 `.` 的方式获取深层的属性

invert：把对象中的`key`和`value`对调

keys：获取对象中所有的`key`，包括深层的（表示成a.b的形式）

lowerize：将对象的所有`key`转换为小写形式

upperize：将对象的所有`key`转换为大写形式

mapKeys：把对象的`kye`通过一个映射函数转换为新的`key`

mapValues：对象的`value`通过一个映射函数转换为新的`value`

omit：创建一个省略了 `keys` 数组中指定的一些键的新对象

pick：创建一个只包含原始对象中指定的 `keys`的对象

isPromise：判断一个值是否为`Promise`

isSymbol：判断一个值是否为`Symbol`类型