GitHub

@liuli-util/async

Install using

npm install @liuli-util/async

Exported Members

You can access these members by importing the module:

import { member } from '@liuli-util/async';

asyncLimiting

function asyncLimiting < T : (...args: any[]) => Promise<any> > (
   fn : T ,
   limit : number
) : T

包装一个异步函数为有限制并发功能的函数

@param:

fn 异步函数

@param:

limit 并发限制数量

@returns:

返回被包装后的限制并发功能的函数

concatMap

function concatMap < T : (...args: any[]) => Promise<any> > (
   fn : T
) : T

将一个异步函数包装为具有时序的异步函数 注: 该函数会按照调用顺序依次返回结果,后面的执行的调用(不是调用结果)需要等待前面的,此函数适用于异步函数的内里执行也必须保证顺序时使用,否则请使用 mergeMap 函数 注: 该函数其实相当于调用 {@code asyncLimiting(fn, {limit: 1})} 函数 例如即时保存文档到服务器,当然要等待上一次的请求结束才能请求下一次,不然数据库保存的数据就存在谬误了

@param:

fn 一个普通的异步函数

@returns:

包装后的函数

debounce

function debounce < T : (...args: any[]) => any , R : (...args: Parameters<T>) => Promise<ReturnType<T>> > (
   fn : T ,
   delay : number ,
   init : any = null
) : R

函数去抖 去抖 (debounce) 去抖就是对于一定时间段的连续的函数调用,只让其执行一次 注: 包装后的函数如果两次操作间隔小于 delay 则不会被执行, 如果一直在操作就会一直不执行, 直到操作停止的时间大于 delay 最小间隔时间才会执行一次, 不管任何时间调用都需要停止操作等待最小延迟时间 应用场景主要在那些连续的操作, 例如页面滚动监听, 包装后的函数只会执行最后一次 注: 该函数第一次调用一定不会执行,第一次一定拿不到缓存值,后面的连续调用都会拿到上一次的缓存值。如果需要在第一次调用获取到的缓存值,则需要传入第三个参数 {@param init},默认为 {@code undefined} 的可选参数 注: 返回函数结果的高阶函数需要使用 {@see Proxy} 实现,以避免原函数原型链上的信息丢失

@param:

fn 真正需要执行的操作

@param:

delay 最小延迟时间,单位为 ms

@param:

init 初始的缓存值,不填默认为 {@see undefined}

@return:

包装后有去抖功能的函数。该函数是异步的,与需要包装的函数 {@param fn} 是否异步没有太大关联

exhaustMap

function exhaustMap < T : (...args: any[]) => Promise<any> > (
   fn : T
) : (...args: Parameters<T>) => Promise<PromiseValue<ReturnType<T>> | void>

将一个异步函数包装为具有时序的异步函数 注: 该函数会阻止的异步操作,非常类似于 asyncLimiting(1),但不同之处在于它会直接抛弃掉并发的请求

@param:

fn 一个普通的异步函数

@returns:

包装后的函数

mergeMap

function mergeMap < T : (...args: any[]) => Promise<any> > (
   fn : T
) : T

将一个异步函数包装为具有时序的异步函数 注: 该函数会按照调用顺序依次返回结果,后面的调用的结果需要等待前面的,所以如果不关心过时的结果,请使用 switchMap 函数

@param:

fn 一个普通的异步函数

@returns:

包装后的函数

switchMap

function switchMap < T : (...args: any[]) => Promise<any> > (
   fn : T
) : T

将一个异步函数包装为具有时序的异步函数 注: 该函数会丢弃过期的异步操作结果,这样的话性能会稍稍提高(主要是响应比较快的结果会立刻生效而不必等待前面的响应结果)

@param:

fn 一个普通的异步函数

@returns:

包装后的函数

throttle

function throttle < T : (...args: any[]) => any , R : (...args: Parameters<T>) => Promise<ReturnType<T>> > (
   fn : T ,
   delay : number
) : R

函数节流 节流 (throttle) 让一个函数不要执行的太频繁,减少执行过快的调用,叫节流 类似于上面而又不同于上面的函数去抖, 包装后函数在上一次操作执行过去了最小间隔时间后会直接执行, 否则会忽略该次操作 与上面函数去抖的明显区别在连续操作时会按照最小间隔时间循环执行操作, 而非仅执行最后一次操作 注: 该函数第一次调用一定会执行,不需要担心第一次拿不到缓存值,后面的连续调用都会拿到上一次的缓存值 注: 返回函数结果的高阶函数需要使用 {@see Proxy} 实现,以避免原函数原型链上的信息丢失

@param:

delay 最小间隔时间,单位为 ms

@param:

fn 真正需要执行的操作

@return:

包装后有节流功能的函数。该函数是异步的,与需要包装的函数 {@param fn} 是否异步没有太大关联

wait

function wait (
   param ? : number | (() => boolean)
) : Promise<void>

等待指定的时间/等待指定表达式成立 如果未指定等待条件则立刻执行 注: 此实现在 nodejs 10- 会存在宏任务与微任务的问题,切记 async-await 本质上还是 Promise 的语法糖,实际上并非真正的同步函数!!!即便在浏览器,也不要依赖于这种特性。

@param:

param 等待时间/等待条件

@returns:

Promise 对象

AsyncArray

class AsyncArray < T >

异步数组,支持静态方法和链式调用

Constructors

constructor

function undefined (
   readonly arr : T[]
) : any

No docs provided

Properties

Methods

static reduce (...)

function reduce < T : any[] , R > (
   arr : T ,
   fn : (res: R, item: IterableElement<T>, index: number) => Promise<R> ,
   res : R
) : Promise<R>

No docs provided

static map (...)

function map < T , R > (
   arr : T[] ,
   fn : (item: T, index: number) => Promise<R>
) : Promise<R[]>

No docs provided

static async filter (...)

async function filter < T > (
   arr : T[] ,
   fn : (item: T, index: number) => Promise<boolean>
) : Promise<T[]>

No docs provided

static async flatMap (...)

async function flatMap < T , R > (
   arr : T[] ,
   fn : (item: T, index: number) => Promise<R[]>
) : Promise<R[]>

No docs provided

static async forEach (...)

async function forEach < T : any[] > (
   arr : T ,
   fn : (item: IterableElement<T>, index: number) => Promise<void>
) : Promise<void>

No docs provided

map (...)

function map < R > (
   fn : (item: T, index: number) => Promise<R>
) : AsyncArray<R>

No docs provided

flatMap (...)

function flatMap < R > (
   fn : (item: T, index: number) => Promise<R[]>
) : AsyncArray<R>

No docs provided

filter (...)

function filter (
   fn : (item: T, index: number) => Promise<boolean>
) : this

No docs provided

async forEach (...)

async function forEach < R > (
   fn : (item: T, index: number) => Promise<R>
) : Promise<void>

No docs provided

then (...)

function then < TResult1 = T[] , TResult2 = never > (
   resolve ? : | ((value: T[]) => PromiseLike<TResult1> | TResult1) | undefined | null ,
   reject ? : | ((reason: any) => PromiseLike<TResult2> | TResult2) | undefined | null
) : PromiseLike<TResult1 | TResult2>

No docs provided