数组方法

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

flat

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

import { flat } from 'radash'

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

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

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

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

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]

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

对象方法

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'

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

用于在一个对象中设置一个值，该值位于由点或方括号表示法指定的路径上。如果路径中的任何中间对象不存在，set 函数将创建它们

import { set } from 'radash'
 
set({}, 'name', 'ra')
// => { name: 'ra' }
 
set({}, 'cards[0].value', 2)
// => { cards: [{ value: 2 }] }

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 }

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 }

通用方法

防抖

import { debounce } from 'radash'

const makeSearchRequest = (event:any) => {
  console.log('searching...')
  console.log(event)
}
let mfun = debounce({ delay: 100 }, makeSearchRequest)// 延迟100ms执行

mfun('hello1')
mfun('hello2')
mfun('hello3')

// mfun.cancel()  // 取消执行

// mfun.flush('2333')// 立即执行

节流 throttle

import { throttle } from 'radash'
 
// 请求接口
const getUser = async () => {
    const { data } = await infUser()
}
 
const jieLiu = throttle({ interval: 2000 }, () => {
    // interval: 2000 间隔 2000 毫秒内只请求 1 次
    getUser ()
})

retry() - 重试失败的异步操作

用于重试失败的异步操作，直到成功或达到最大重试次数。

import { retry } from 'radash';

async function fetchData() {
  try {
    const response = await fetch('api/data');
    return response.json();
  } catch (error) {
    throw error;
  }
}

// 尝试最多 3 次，每次失败后等待 2 秒
const data = await retry({ times: 3, delay: 2000 }, fetchData);
console.log(data);

是否日期 isDate

import { isDate } from 'radash'
 
isDate(new Date()) // => true
isDate(12)         // => false
isDate('hello')    // => false

是否为空 isEmpty

import { isEmpty } from 'radash'
 
isEmpty([]) // => true
isEmpty('') // => true
isEmpty(null) // => true
isEmpty({}) // => true
isEmpty(0) // => true
isEmpty(NaN) // => true
isEmpty(undefined) // => true
 
isEmpty('hello')   // => false
isEmpty(['hello']) // => false

是否相等 isEqual

import { isEqual } from 'radash'
 
isEqual(null, null) // => true
isEqual([], [])     // => true
 
isEqual('hello', 'world') // => false
isEqual(22, 'abc')        // => false

是否函数 isFunction

import { isFunction } from 'radash'
 
isFunction('hello') // => false
isFunction(['hello']) // => false
isFunction(() => 'hello') // => true

tryit方法

tryit: 方法相当于可以帮你给异步操作加一层 try catch，有利于操作的兜底以及错误的捕获

import { tryit } from 'radash'
 
const [err,user] = await tryit(async () => {
  const { data } = await infUser()
  return data
})(userId)
 
if(err) {
  console.log('err',err)
} else {
  console.log('user',user)
}

parallel 方法

parallel 你可以理解为它是 Promise.all 的加强版，它不止能帮你做多个异步操作的并发处理，还能帮你控制并发数量

import { paraller } from 'radash'

const userIds = [1,2,3,4,5,6,7,8,9,10]
 
const users = await paraller(3,userIds,async (userId) => {
  const { data } = await infUser(userId)
  return data
})