Question

假设我正在使用提供以下类的外部库：

Class A {
  ...overloads types
  doSomething(param, params) {

  }
}

我想覆盖super方法并提供实现，但是我想保留原始类型。（包括超载）

Class B extends A {
   doSomething(param, params) {
     // ...some logic
     super.doSomething(); 
   }
}

有没有办法用Typescript做到这一点？

Answer 1

应该完全按照您的描述进行操作：

class A {
  test() {
    return 'from class A';
  }
}

class B extends A {
  test() {
    return super.test() + ' and from class B';
  }
}

您可以在typescript playground

上使用它

要保留args：

class A {
  test(a: number) {
    return `from class A ${a}`;
  }
}

class B extends A {
  test: A['test'] = (...args) => {
    return super.test(...args) + ' and from class B';
  }
}

，如果要在原型上使用它：

class A {
  test(param: number | string): void {
    console.log(param);
  }
}

type ArgumentsType<T> = T extends (...args: infer A) => any ? A : never;

class B extends A {
  test(...args: ArgumentsType<A['test']>): ReturnType<A['test']> {
    return super.test(...args);
  }
}

Answer 2

Typescript不会根据基本类型推断参数类型。事情的方式是，单独键入该类，然后检查与基类的不一致之处。这也意味着没有办法阻止基类的重载。

可以减少语法的一种方法是将其分配给B的原型

class A {
    doSomething(param: number, params: number)
    doSomething(param: string, params: string)
    doSomething(param: number | string, params: number | string) {
        alert ("A")
    }
}

class B extends A {

}

B.prototype.doSomething = function doSomething(this: B, param, params) {
    alert("B");
    A.prototype.doSomething.call(this, arguments);
} 

new A().doSomething(0, 0)
new B().doSomething(0,0)

通过这种方式可以推断参数的类型，如果您有this的显式注释，则可以在函数内正确键入参数。唯一的缺点是您必须使用相当大的语法来发出超级调用

Answer 3

语法将非常笨拙，您将不再利用原型，而是在构造函数中定义该方法，这可能会对性能产生影响，但这可以：

def cookies_required
   return true unless request.cookies.blank?  
   render :template => "shared/cookies_required", :layout => "login"
end

打字稿是指与super方法相同的类型

3 个答案: