Question

这是代码

class A {
    x = 0;
    y = 0;
    visible = false;
    render() {
        return 1;
    }
}

type RemoveProperties<T> = {
    readonly [P in keyof T]: T[P] extends Function ? T[P] : never//;
};

type JustMethodKeys<T> = ({ [P in keyof T]: T[P] extends Function ? P : never })[keyof T];
type JustMethods<T> = Pick<T, JustMethodKeys<T>>;


type IsValidArg<T> = T extends object ? keyof T extends never ? false : true : true;

type Promisified<T extends Function> =
    T extends (...args: any[]) => Promise<any> ? T : (
        T extends (a: infer A, b: infer B, c: infer C, d: infer D, e: infer E, f: infer F, g: infer G, h: infer H, i: infer I, j: infer J) => infer R ? (
            IsValidArg<J> extends true ? (a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I, j: J) => Promise<R> :
            IsValidArg<I> extends true ? (a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I) => Promise<R> :
            IsValidArg<H> extends true ? (a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H) => Promise<R> :
            IsValidArg<G> extends true ? (a: A, b: B, c: C, d: D, e: E, f: F, g: G) => Promise<R> :
            IsValidArg<F> extends true ? (a: A, b: B, c: C, d: D, e: E, f: F) => Promise<R> :
            IsValidArg<E> extends true ? (a: A, b: B, c: C, d: D, e: E) => Promise<R> :
            IsValidArg<D> extends true ? (a: A, b: B, c: C, d: D) => Promise<R> :
            IsValidArg<C> extends true ? (a: A, b: B, c: C) => Promise<R> :
            IsValidArg<B> extends true ? (a: A, b: B) => Promise<R> :
            IsValidArg<A> extends true ? (a: A) => Promise<R> :
            () => Promise<R>
        ) : never
    );



var a = new A() as JustMethods<A>  // I want to JustMethod && Promisified
a.visible // error
var b = a.render() // b should be Promise<number>

如何实施？我想删除visible和promisify render方法，如何组合Promisified和JustMethods？

Answer 1

您需要使用映射类型，该类型仅使用JustMethodKeys类型的方法，并在每个属性上使用Promisified

class A {
    x = 0;
    y = 0;
    visible = false;
    render() {
        return 1;
    }
}

type JustMethodKeys<T> = ({ [P in keyof T]: T[P] extends Function ? P : never })[keyof T];

type IsValidArg<T> = T extends object ? keyof T extends never ? false : true : true;

type Promisified<T extends Function> =
    T extends (...args: any[]) => Promise<any> ? T : (
        T extends (a: infer A, b: infer B, c: infer C, d: infer D, e: infer E, f: infer F, g: infer G, h: infer H, i: infer I, j: infer J) => infer R ? (
            IsValidArg<J> extends true ? (a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I, j: J) => Promise<R> :
            IsValidArg<I> extends true ? (a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I) => Promise<R> :
            IsValidArg<H> extends true ? (a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H) => Promise<R> :
            IsValidArg<G> extends true ? (a: A, b: B, c: C, d: D, e: E, f: F, g: G) => Promise<R> :
            IsValidArg<F> extends true ? (a: A, b: B, c: C, d: D, e: E, f: F) => Promise<R> :
            IsValidArg<E> extends true ? (a: A, b: B, c: C, d: D, e: E) => Promise<R> :
            IsValidArg<D> extends true ? (a: A, b: B, c: C, d: D) => Promise<R> :
            IsValidArg<C> extends true ? (a: A, b: B, c: C) => Promise<R> :
            IsValidArg<B> extends true ? (a: A, b: B) => Promise<R> :
            IsValidArg<A> extends true ? (a: A) => Promise<R> :
            () => Promise<R>
        ) : never
    );

type PromisifyMethods<T> = { 
    // We take just the method key and Promisify them, 
    // We have to use T[P] & Function because the compiler will not realize T[P] will always be a function
    [P in JustMethodKeys<T>] : Promisified<T[P] & Function>
}

//Usage
declare var a : PromisifyMethods<A>  
a.visible // error
var b = a.render() // b is Promise<number>

修改

由于原始问题得到解答，打字稿已经改进了这个问题的可能解决方案。添加Tuples in rest parameters and spread expressions后，我们现在不需要Promisified的所有重载：

type JustMethodKeys<T> = ({ [P in keyof T]: T[P] extends Function ? P : never })[keyof T];


type ArgumentTypes<T> = T extends (... args: infer U ) => any ? U: never;
type Promisified<T> = T extends (...args: any[])=> infer R ? (...a: ArgumentTypes<T>) => Promise<R> : never;

type PromisifyMethods<T> = { 
    // We take just the method key and Promisify them, 
    // We have to use T[P] & Function because the compiler will not realize T[P] will always be a function
    [P in JustMethodKeys<T>] : Promisified<T[P]>
}

//Usage
declare var a : PromisifyMethods<A>  
a.visible // error
var b = a.render("") // b is Promise<number> , render is render: (k: string) => Promise<number>

这不仅缩短了，而且解决了许多问题

可选参数保持可选
保留参数名称
适用于任意数量的论点

Answer 2

类似于另一个答案，但这是我得出的结论

type Method = (...args: any) => any;
type KeysOfMethods<T> = ({ [P in keyof T]: T[P] extends Method ? P : never })[keyof T];
type PickMethods<T> = Pick<T, KeysOfMethods<T>>;
type Promisify<T> = T extends Promise<infer U> ? Promise<U> : Promise<T>;
type PromisifyMethod<T extends Method> = (...args: Parameters<T>) => Promisify<ReturnType<T>>;
type PromisifyMethods<T> = { [P in keyof T]: T[P] extends Method ? PromisifyMethod<T[P]> : T[P] };

type PromisifiedMethodsOnly<T> = PickMethods<PromisifyMethods<T>>

如何在TypeScript中通过映射类型删除属性和promisify方法

2 个答案: