有没有办法用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);

根据规范，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);
    }
}

为清楚起见进行更新。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 {
  //...
}

我希望。我也想要此功能，但TypeScript需要与没有重载方法的无类型JavaScript互操作。即，如果您的重载方法是从JavaScript调用的，则只能将其分派到一个方法实现中。

关于Codeplex的相关讨论很少。例如

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

我仍然认为TypeScript应该生成所有if'ing和switch，因此我们不需要这样做。

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

对于此问题，仅使用使用一些可选属性定义的内联接口可以直接编写如下代码：

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中函数重载的使用不像支持真正重载功能的语言那样舒适。

但是，仍然有很多以打字稿提供的方便的新东西，而这在旧版编程语言中是不可用的，我认为，匿名接口中的可选属性支持就是这样一种方法，可以满足旧版函数重载的要求。

如果方法重载有很多变化，另一种方法就是创建一个包含所有args的类。因此，您可以按任何顺序仅传递所需的参数。

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);

Javascript没有任何重载的概念。Typescript不是c＃或Java。

但是您可以在Typescript中实现重载。

阅读这篇文章 http://www.gyanparkash.in/function-overloading-in-typescript/