Radash是下一个你不能没有的库。首先，也是最重要的，它很强大。有了这些强大的函数，你就可以得到强大的类型和零依赖性。如果你能踏出一点信心，尝试一下这些函数，我毫不怀疑你会发现自己爱上了它。

安装

npm install radash --save
// 或 yarn下载
yarn add radash

// 引入
import * as _ from 'radash'

demo

import * as _ from 'radash'

const gods = [{
  name: 'Ra',
  power: 'sun',
  rank: 100,
  culture: 'egypt'
}, {
  name: 'Loki',
  power: 'tricks',
  rank: 72,
  culture: 'norse'
}, {
  name: 'Zeus',
  power: 'lightning',
  rank: 96,
  culture: 'greek'
}]

_.max(gods, g => g.rank) // => ra
_.sum(gods, g => g.rank) // => 268
_.fork(gods, g => g.culture === 'norse') // => [[loki], [ra, zeus]]
_.sort(gods, g => g.rank) // => [ra, zeus, loki]
_.boil(gods, (a, b) => a.rank > b.rank ? a : b) // => ra

_.objectify(
  gods,
  g => g.name.toLowerCase(),
  g => _.pick(g, ['power', 'rank', 'culture'])
) // => { ra, zeus, loki }

const godName = _.get(gods, g => g[0].name)

const [err, god] = await _.try(api.gods.findByName)(godName)

const allGods = await _.map(gods, async ({ name }) => {
  return api.gods.findByName(name)
})

数组方法

alphabetical

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

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

boil：返回对象数组中满足条件的对象

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

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

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

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

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

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

diff

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

import { diff } from 'radash'

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

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

first

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

import { first } from 'radash'

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

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

flat

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

import { flat } from 'radash'

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

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

fork

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

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

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

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

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

import { iterate } from 'radash'

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

last

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

import { last } from 'radash'

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

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

list/range

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

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

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

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

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

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

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

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 }

replaceOrAppend

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

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

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

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

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

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

import { sift } from 'radash'

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

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

sort

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

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

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

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

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

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

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

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

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

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/upperize：将对象的所有key转换为小写/大写形式

用于将一个对象的所有键转换为小写形式，内部用到mapKeys，而 mapKeys 函数则用于一般性地将一个对象的键通过一个映射函数转换为新的键

import { lowerize } from 'radash'
 
const ra = {
  Mode: 'god',
  Power: 'sun'
}
 
lowerize(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 { clone } from 'radash'
 
const ra = {
  name: 'Ra',
  power: 100
}
 
const gods = [ra]
 
clone(ra) // => copy of ra
clone(gods) // => copy of gods

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

创建一个新的对象，该对象是原始对象 obj 的副本，但省略了 keys 数组中指定的一些键。这个函数接受两个参数：一个对象 obj 和一个包含要省略键名的数组 keys

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

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 }

radash 使用介绍

安装

demo

数组方法

alphabetical

boil

cluster

counting

diff

first

flat

fork

group

intersects

iterate

last

list/range

max

merge

min

objectify

replaceOrAppend

replace

select

shift

sift

sort

sum

toggle

unique

zipToObject

zip

对象方法

assign：递归合并两个对象

clone：浅拷贝对象

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

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

get

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

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

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

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

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

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

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

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

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

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

shake：过滤对象