函数处理相关方法

预计阅读时间: 3 分钟

cacheByReturn

缓存函数返回值

类型声明

1type TAnyFunc = (...args: any[]) => any;
2type TCacheByReturnType<F extends () => any, R = ReturnType<F>> = R extends TAnyFunc ? R : () => R;
3
4function cacheByReturn<F extends () => any>(cacheLoad: F): TCacheByReturnType<F>;

参数

必填	参数	说明	类型	默认值
*	cacheLoad	缓存加载函数	F	-

返回值: TCacheByReturnType<F>

示例

1import { cacheByReturn } from '@cmtlyt/base';
2// import { cacheByReturn } from '@cmtlyt/base/utils/funcHandler';
3
4const cacheLoad = () => {
5  console.log('cacheLoad');
6  return 'hello world';
7};
8const cachedLoad = cacheByReturn(cacheLoad);
9console.log(cachedLoad()); // cacheLoad \n hello world
10console.log(cachedLoad()); // hello world

memoize

缓存函数

类型声明

1function memoize<F extends TAnyFunc>(func: F, resolver?: (...args: TArgsType<F>) => any): F;

参数

必填	参数	说明	类型	默认值
*	func	缓存加载函数	F	-
	resolver	缓存解析函数	F	-

返回值: F

示例

1import { memoize } from '@cmtlyt/base';
2// import { memoize } from '@cmtlyt/base/utils/funcHandler';
3
4const fn = (a: number, b: number) => {
5  console.log('fn');
6  return a + b;
7};
8const memoizedFn = memoize(fn);
9memoizedFn(1, 2); // fn \n 3
10memoizedFn(1, 2); // 3
11memoizedFn(1, 2); // 3
12memoizedFn(2, 2); // fn \n 4
13memoizedFn(2, 2); // 4
14memoizedFn(1, 3); // fn \n 4
15memoizedFn(1, 3); // 4

curry

将普通函数转换为柯里化函数

不放类型声明了，太过复杂

参数

必填	参数名	类型	说明	默认值
*	fn	TAnyFunc	需要转换的函数	-

返回值: 柯里化后的函数

示例

1import { curry } from '@cmtlyt/base';
2// import { curry } from '@cmtlyt/base/utils/funcHandler';
3
4const add = (a: number, b: number) => a + b;
5const curriedAdd = curry(add);
6curriedAdd(1)(2); // 3
7curriedAdd(1, 2); // 3

compose

组合函数，从右到左执行

不放类型声明了，太过复杂

参数

必填	参数名	类型	说明	默认值
*	funcs	TAnyFunc[]	需要组合的函数	-

返回值: 组合后的函数

示例

1import { compose, curry } from '@cmtlyt/base';
2// import { compose, curry } from '@cmtlyt/base/utils/funcHandler';
3
4const add = curry((a: number, b: number) => a + b);
5const multiply = curry((a: number, b: number) => a * b);
6const addAndMultiply = compose(multiply(2), add);
7addAndMultiply(1, 2); // 6

pipe

组合函数，从左到右执行

不放类型声明了，太过复杂

参数

必填	参数名	类型	说明	默认值
*	funcs	TAnyFunc[]	需要组合的函数	-

返回值: 组合后的函数

示例

1import { pipe, curry } from '@cmtlyt/base';
2// import { pipe, curry } from '@cmtlyt/base/utils/funcHandler';
3
4const add = curry((a: number, b: number) => a + b);
5const multiply = curry((a: number, b: number) => a * b);
6const addAndMultiply = pipe(add, multiply(2));
7addAndMultiply(1, 2); // 6

debounce

函数防抖

类型声明

1type TArgsType<F> = F extends (...args: infer T) => any ? T : never;
2
3function debounce<F extends (...args: any[]) => any>(
4  func: F,
5  time?: number,
6  immediately?: boolean,
7): (...args: TArgsType<F>) => void;

参数

必填	参数名	说明	类型	默认值
*	func	要防抖的函数	F	-
	time	防抖时间，默认为 100ms	number	100
	immediately	是否立即执行，默认为 false	boolean	false

返回值: (...args: TArgsType<F>) => void

示例

1import { debounce } from '@cmtlyt/base';
2// import { debounce } from '@cmtlyt/base/utils/funcHandler'
3
4const fn = debounce(() => {
5  console.log('hello');
6}, 1000);
7
8fn();
9fn();
10fn();
11fn(); // hello
12
13setTimeout(() => {
14  fn(); // hello
15}, 1500);

throttle

函数节流

类型声明

1type TArgsType<F> = F extends (...args: infer T) => any ? T : never;
2
3function throttle<F extends (...args: any[]) => any>(
4  func: F,
5  time?: number,
6  immediately?: boolean,
7): (...args: TArgsType<F>) => void;

参数

必填	参数名	说明	类型	默认值
*	func	要节流的函数	F	-
	time	节流时间，默认为 100ms	number	100
	immediately	是否立即执行，默认为 true	boolean	true

返回值: (...args: TArgsType<F>) => void

示例

1import { throttle } from '@cmtlyt/base';
2// import { throttle } from '@cmtlyt/base/utils/funcHandler'
3
4const fn = throttle(() => {
5  console.log('hello');
6}, 1000);
7
8fn(); // hello
9fn();
10fn();
11fn();
12
13setTimeout(() => {
14  fn(); // hello
15}, 1500);

chunkTask

大任务分块执行

类型声明

1export declare function chunkTask<T, F extends (arg: T) => any = (arg: T) => any>(
2  task: F,
3): <R extends TUnwrapPromise<ReturnType<F>>>(args: T[] | number) => Promise<R>;

参数

必填	参数名	说明	类型	默认值
*	task	任务	F	-

返回值: (args: T[] | number) => Promise<TCast<ReturnType<F>, Promise<any>>>

示例

1import { chunkTask } from '@cmtlyt/base';
2// import { chunkTask } from '@cmtlyt/base/utils/funcHandler';
3
4const task = async (arg: number) => {
5  return new Promise((resolve) => {
6    setTimeout(() => {
7      resolve(arg);
8    }, 1000);
9  });
10};
11const chunkedTask = chunkTask(task);
12chunkedTask([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]); // [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

sleep

等待指定时间

类型声明

1function sleep(time: number): Promise<void>;

参数

必填	参数名	说明	类型	默认值
*	time	时间	number	-

返回值: Promise<void>

示例

1import { sleep } from '@cmtlyt/base';
2// import { sleep } from '@cmtlyt/base/utils/funcHandler';
3
4sleep(1000).then(() => {
5  console.log('hello');
6});

1export function reverseArgs<F extends TAnyFunc>(callback: F) {
2  return (...args: ReverseArray<Parameters<F>>): ReturnType<F> => callback.apply(null, args.reverse());
3}

reverseArgs

反转函数参数

参数

必填	参数名	说明	类型	默认值
*	callback	回调	F	-

返回值: (...args: ReverseArray<TArgsType<F>>) => ReturnType<F>

示例

1import { reverseArgs } from '@cmtlyt/base';
2// import { reverseArgs } from '@cmtlyt/base/utils/funcHandler';
3
4const fn = (a: number, b: string) => {
5  return `${a} + ${b} = ${a + b}`;
6};
7const reversedFn = reverseArgs(fn);
8reversedFn('1', 2); // 1 + 2 = 3

基础工具

通用工具

函数处理相关方法

cacheByReturn

memoize

curry

compose

pipe

debounce

throttle

chunkTask

sleep

reverseArgs

#函数处理相关方法

#cacheByReturn

#memoize

#curry

#compose

#pipe

#debounce

#throttle

#chunkTask

#sleep

#reverseArgs

函数处理相关方法

cacheByReturn

memoize

curry

compose

pipe

debounce

throttle

chunkTask

sleep

reverseArgs