有没有办法在TypeScript中进行方法重载？ [英] Is there a way to do method overloading in TypeScript?

问题描述

有没有办法在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（v＃1的字符串）; 
 testClass.someMethod（12345，v＃2的字符串）; 
  

以下是我不想做的一个例子（我真的很讨厌那部分重载hack in JS）：

  class TestClass {
 private someMethod_Overload_string（stringParameter：string）：void {
 //很多代码可以在这里......我不想把它与switch或if语句混合在一般函数
 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]）; 
返回; 
} 
返回; //这种情况下无法访问的区域，不必要的返回语句
情况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]）; 
} 
返回; //这种情况下无法访问的区域，不必要的返回语句
} 
} 
} 
 
 
 var testClass = new TestClass（）; 
 testClass.someMethod（v＃1的字符串）; 
 testClass.someMethod（12345，v＃2的字符串）; 
 testClass.someMethod（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）; 
} 
} 
  

Is there a way to do method overloading in TypeScript language?

I want to achieve something like this:

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

Here is an example of what I don't want to do (I really hate that part of overloading hack in JS):

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

解决方案

According to the specification, TypeScript does support method overloading, but it's quite awkward and includes a lot of manual work checking types of parameters. I think it's mostly because the closest you can get to method overloading in plain JavaScript includes that checking too and TypeScript tries to not modify actual method bodies to avoid any unnecessary runtime performance cost.

If I understand it correctly, you have to first write a method declaration for each of the overloads and then one method implementation that checks its arguments to decide which overload was called. The signature of the implementation has to be compatible with all of the overloads.

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中进行方法重载？的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！