让我们假设我有一个A
装饰器,它被应用于返回字符串的方法。装饰器使用该字符串,最后返回B
类型(类)。
class B {
constructor(text: string) { ... }
method() {...}
}
class X {
@A
someMethod(): string {
return 'lalala';
}
}
装饰者
function A(target, property, descriptor) {
const text: string = descriptor.value();
descriptor.value = () => new B(text);
}
发生什么事了?现在someMethod
返回B
对象而不是字符串。但我做不到这样的事情:
class X {
constructor() {
this.someMethod().method();
}
@A
someMethod(): string {
return 'lala';
}
}
为什么呢?因为定义中的someMethod
是字符串类型,但装饰器使其返回B
类型。我能否以某种方式让打字稿知道someMethod
实际上会返回B
,而不是string
?
答案 0 :(得分:1)
请参阅下面的3.0解决方案
装饰器不能改变类型的结构,没有类型的装饰器可以做到这一点(类,方法或参数装饰器)
使用Typescript 2.8,您可以编写一个函数,将另一个函数作为参数并执行返回类型的更改,但是您将丢失参数名称,可选参数和多个签名等内容。此外,您应该注意,因为这样做会使someMethod
字段分配方法,而不是类方法。因此,必须在每个构造函数中分配字段,而不是将其分配给prototype
一次,这可能会影响性能。
class B<T> {
constructor(public value: T) { }
method() { return this.value; }
}
function A<T extends (...args: any[]) => any>(fn: T): ReplaceReturnType<T, B<ReturnType<T>>> {
return function (this: any, ...args: any[]) {
return new B<ReturnType<T>>(fn.apply(this, args));
} as any;
}
class X {
constructor() {
this.someMethod().method();
}
other() {}
someMethod = A(function (this: X): string {
this.other(); // We can access other members because of the explicit this parameter
return 'lala';
});
}
type IsValidArg<T> = T extends object ? keyof T extends never ? false : true : true;
type ReplaceReturnType<T, TNewReturn> = 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) => TNewReturn :
IsValidArg<I> extends true ? (a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I) => TNewReturn :
IsValidArg<H> extends true ? (a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H) => TNewReturn :
IsValidArg<G> extends true ? (a: A, b: B, c: C, d: D, e: E, f: F, g: G) => TNewReturn :
IsValidArg<F> extends true ? (a: A, b: B, c: C, d: D, e: E, f: F) => TNewReturn :
IsValidArg<E> extends true ? (a: A, b: B, c: C, d: D, e: E) => TNewReturn :
IsValidArg<D> extends true ? (a: A, b: B, c: C, d: D) => TNewReturn :
IsValidArg<C> extends true ? (a: A, b: B, c: C) => TNewReturn :
IsValidArg<B> extends true ? (a: A, b: B) => TNewReturn :
IsValidArg<A> extends true ? (a: A) => TNewReturn :
() => TNewReturn
) : never
修改
由于原始问题得到解答,打字稿已经改进了这个问题的可能解决方案。添加Tuples in rest parameters and spread expressions后,我们现在不需要ReplaceReturnType
的所有重载:
type ArgumentTypes<T> = T extends (... args: infer U ) => infer R ? U: never;
type ReplaceReturnType<T, TNewReturn> = (...a: ArgumentTypes<T>) => TNewReturn;
这不仅缩短了,而且解决了许多问题
样品:
type WithOptional = ReplaceReturnType<(n?: number)=> string, Promise<string>>;
let x!: WithOptional; // Typed as (n?: number) => Promise<string>
x() // Valid
x(1); //Ok