有没有办法在 TypeScript 中进行方法重载?

IT技术 javascript typescript operator-overloading
2021-01-20 02:11:05

有没有办法在 TypeScript 语言中进行方法重载?

我想实现这样的目标:

class TestClass {
    someMethod(stringParameter: string): void {
        alert("Variant #1: stringParameter = " + stringParameter);
    }

    someMethod(numberParameter: number, stringParameter: string): void {
        alert("Variant #2: numberParameter = " + numberParameter + ", stringParameter = " + stringParameter);
    }
}

var testClass = new TestClass();
testClass.someMethod("string for v#1");
testClass.someMethod(12345, "string for v#2");

这是我不想做的一个例子(我真的很讨厌在 JS 中重载 hack 的那部分):

class TestClass {
    private someMethod_Overload_string(stringParameter: string): void {
        // A lot of code could be here... I don't want to mix it with switch or if statement in general function
        alert("Variant #1: stringParameter = " + stringParameter);
    }

    private someMethod_Overload_number_string(numberParameter: number, stringParameter: string): void {
        alert("Variant #2: numberParameter = " + numberParameter + ", stringParameter = " + stringParameter);
    }

    private someMethod_Overload_string_number(stringParameter: string, numberParameter: number): void {
        alert("Variant #3: stringParameter = " + stringParameter + ", numberParameter = " + numberParameter);
    }

    public someMethod(stringParameter: string): void;
    public someMethod(numberParameter: number, stringParameter: string): void;
    public someMethod(stringParameter: string, numberParameter: number): void;

    public someMethod(): void {
        switch (arguments.length) {
        case 1:
            if(typeof arguments[0] == "string") {
                this.someMethod_Overload_string(arguments[0]);
                return;
            }
            return; // Unreachable area for this case, unnecessary return statement
        case 2:
            if ((typeof arguments[0] == "number") &&
                (typeof arguments[1] == "string")) {
                this.someMethod_Overload_number_string(arguments[0], arguments[1]);
            }
            else if ((typeof arguments[0] == "string") &&
                     (typeof arguments[1] == "number")) {
                this.someMethod_Overload_string_number(arguments[0], arguments[1]);
            }
            return; // Unreachable area for this case, unnecessary return statement
        }
    }
}


var testClass = new TestClass();
testClass.someMethod("string for v#1");
testClass.someMethod(12345, "string for v#2");
testClass.someMethod("string for v#3", 54321);
5个回答

根据规范,TypeScript 确实支持方法重载,但它非常笨拙,并且包含大量手动工作检查参数类型。我认为这主要是因为在普通 JavaScript 中最接近方法重载的方法也包括检查,并且 TypeScript 试图不修改实际的方法主体以避免任何不必要的运行时性能成本。

如果我理解正确,您必须首先为每个重载编写一个方法声明,然后编写一个方法实现来检查其参数以确定调用哪个重载。实现的签名必须与所有重载兼容。

class TestClass {
    someMethod(stringParameter: string): void;
    someMethod(numberParameter: number, stringParameter: string): void;

    someMethod(stringOrNumberParameter: any, stringParameter?: string): void {
        if (stringOrNumberParameter && typeof stringOrNumberParameter == "number")
            alert("Variant #2: numberParameter = " + stringOrNumberParameter + ", stringParameter = " + stringParameter);
        else
            alert("Variant #1: stringParameter = " + stringOrNumberParameter);
    }
}
我认为这里重要的是它可以让您的代码保持可读性,而无需进行大量的 if 语句类型检查。谁在乎它转换成什么。
2021-03-20 02:11:05
@NicoVanBelle JavaScript 根本不支持方法重载,对吧?那么回到 JS 会有什么帮助呢?
2021-03-21 02:11:05
嗯..我真的不喜欢这个,只是有一个可选参数更好读。
2021-03-26 02:11:05
检查接口呢?你有比这更好的解决方案stackoverflow.com/questions/14425568/...
2021-04-06 02:11:05

为清楚起见更新。TypeScript 中的方法重载是一项有用的功能,因为它允许您使用需要表示的 API 为现有库创建类型定义。

但是,在编写自己的代码时,您很可能能够避免使用可选或默认参数的重载的认知开销。这是方法重载的更具可读性的替代方法,并且还可以使您的 API 保持诚实,因为您将避免使用不直观的顺序创建重载。

TypeScript 重载的一般规律是:

如果您可以删除重载签名并且所有测试都通过,则不需要 TypeScript 重载

您通常可以使用可选参数或默认参数来实现相同的目的——或者使用联合类型,或者使用一些面向对象的方法。

实际问题

实际问题要求重载:

someMethod(stringParameter: string): void {

someMethod(numberParameter: number, stringParameter: string): void {

现在,即使在支持具有单独实现的重载的语言中(注意:TypeScript 重载共享单个实现) - 程序员建议提供排序的一致性。这将使签名:

someMethod(stringParameter: string): void {

someMethod(stringParameter: string, numberParameter: number): void {

stringParameter始终是必需的,所以先行。你可以把它写成一个有效的 TypeScript 重载:

someMethod(stringParameter: string): void;
someMethod(stringParameter: string, numberParameter: number): void;
someMethod(stringParameter: string, numberParameter?: number): void {
    if (numberParameter != null) {
        // The number parameter is present...
    }
}

但是按照 TypeScript 重载的法则,我们可以删除重载签名,我们所有的测试仍然会通过。

someMethod(stringParameter: string, numberParameter?: number): void {
    if (numberParameter != null) {
        // The number parameter is present...
    }
}

实际问题,按实际顺序

如果您决定坚持原始顺序,则重载将是:

someMethod(stringParameter: string): void;
someMethod(numberParameter: number, stringParameter: string): void;
someMethod(a: string | number, b?: string | number): void {
  let stringParameter: string;
  let numberParameter: number;

  if (typeof a === 'string') {
    stringParameter = a;
  } else {
    numberParameter = a;

    if (typeof b === 'string') {
      stringParameter = b;
    }
  }
}

现在有很多分支来确定在哪里放置参数,但是如果你读到这里,你真的想保留这个顺序……但是等等,如果我们应用 TypeScript 重载定律会发生什么?

someMethod(a: string | number, b?: string | number): void {
  let stringParameter: string;
  let numberParameter: number;

  if (typeof a === 'string') {
    stringParameter = a;
  } else {
    numberParameter = a;

    if (typeof b === 'string') {
      stringParameter = b;
    }
  }
}

足够的分支已经

当然,考虑到我们需要做的类型检查的数量......也许最好的答案就是有两种方法:

someMethod(stringParameter: string): void {
  this.someOtherMethod(0, stringParameter);
}

someOtherMethod(numberParameter: number, stringParameter: string): void {
  //...
}
这取决于您的用例,尤其是您是否接受零。如果您需要这样做,请记住使用!==以避免杂耍。
2021-03-18 02:11:05
这通常不称为方法重载。另见问题,第一个参数的类型发生变化。
2021-03-26 02:11:05
你的意思是if (typeof numberParameter != 'undefined'),对 ;)
2021-04-02 02:11:05
@Sebastian 这听起来像是依赖注入的机会。鉴于 TypeScript 中的方法重载涉及具有多个装饰、默认参数和联合类型的单个方法,可提供更好的体验。如果方法在更实质的方面不同,您要么使用抽象,要么实现多个方法。
2021-04-06 02:11:05
我承认在我的回答中 - 您会将可选参数放在最后,因此该number参数将是第二个参数并且是可选的。TypeScript 不支持“正确的”方法重载 - 但即使是 C# 世界也在从重载转向可选参数,因为在许多情况下它会导致更易读的代码。
2021-04-07 02:11:05

我希望。我也想要这个功能,但 TypeScript 需要与没有重载方法的无类型 JavaScript 互操作。即如果您的重载方法是从 JavaScript 调用的,那么它只能被分派到一个方法实现。

有一些关于 codeplex 的相关讨论。例如

https://typescript.codeplex.com/workitem/617

我仍然认为 TypeScript 应该生成所有的 if'ing 和切换,所以我们不需要这样做。

为什么不使用可选属性定义的接口作为函数参数..

对于这个问题中的情况,使用定义了一些可选属性的内联接口只能直接制作如下代码:

class TestClass {

    someMethod(arg: { stringParameter: string, numberParameter?: number }): void {
        let numberParameterMsg = "Variant #1:";
        if (arg.numberParameter) {
            numberParameterMsg = `Variant #2: numberParameter = ${arg.numberParameter},`;
        }
        alert(`${numberParameterMsg} stringParameter = ${arg.stringParameter}`);
    }
}

var testClass = new TestClass();
testClass.someMethod({ stringParameter: "string for v#1" });
testClass.someMethod({ numberParameter: 12345, stringParameter: "string for v#2" });

因为 TypeScript 提供的重载,正如其他人的评论中提到的,只是一个函数不同签名的列表,并不像其他静态语言那样支持相应的实现代码。所以实现仍然只需要在一个函数体中完成,这使得在 Typescript 中函数重载的使用不如支持真正重载功能的语言那么舒服。

然而,typescript中仍然提供了许多新的和方便的东西,这些东西在遗留编程语言中是不可用的,我认为,匿名接口中的可选属性支持是一种满足遗留函数重载舒适区的方法。

如果方法重载有很多变体,另一种方法是创建一个包含所有参数的类。所以你只能以任何顺序传递你想要的参数。

class SomeMethodConfig {
  stringParameter: string;
  numberParameter: number;

 /**
 *
 */
 constructor(stringParameter: string = '012', numberParameter?: number) { // different ways to make a param optional
   this.numberParameter = 456; // you can put a default value here
   this.stringParameter = stringParameter; // to pass a value throw the constructor if necessary
 }
}

您也可以使用默认值创建构造函数和/或传递一些必需参数。然后像这样使用:

const config = new SomeMethodConfig('text');
config.numberParameter = 123; // initialize an optional parameter only if you want to do it
this.SomeMethod(config);