¿Hay alguna forma de sobrecargar métodos en el lenguaje TypeScript?

Quiero lograr algo como esto:

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

Aquí hay un ejemplo de lo que no quiero hacer (realmente odio esa parte del truco de sobrecarga en 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);

Según la especificación, TypeScript admite la sobrecarga de métodos, pero es bastante incómodo e incluye una gran cantidad de trabajo manual para verificar tipos de parámetros. Creo que se debe principalmente a que lo más cerca que puede llegar a la sobrecarga de métodos en JavaScript simple incluye esa verificación también y TypeScript intenta no modificar los cuerpos de los métodos reales para evitar costos innecesarios de rendimiento en tiempo de ejecución.

Si lo entiendo correctamente, primero debe escribir una declaración de método para cada una de las sobrecargas y luego una implementación de método que verifique sus argumentos para decidir qué sobrecarga se llamó. La firma de la implementación debe ser compatible con todas las sobrecargas.

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

Actualice para mayor claridad. La sobrecarga de métodos en TypeScript es una característica útil en la medida en que le permite crear definiciones de tipo para bibliotecas existentes con una API que necesita ser representada.

Sin embargo, al escribir su propio código, es posible que pueda evitar la sobrecarga cognitiva de las sobrecargas utilizando parámetros opcionales o predeterminados. Esta es la alternativa más legible a las sobrecargas de métodos y también mantiene su API honesta, ya que evitará la creación de sobrecargas con un orden poco intuitivo.

La ley general de las sobrecargas de TypeScript es:

Si puede eliminar las firmas de sobrecarga y todas sus pruebas pasan, no necesita sobrecargas de TypeScript

Por lo general, puede lograr lo mismo con parámetros opcionales o predeterminados, o con tipos de unión, o con un poco de orientación a objetos.

La pregunta real

La pregunta real pide una sobrecarga de:

someMethod(stringParameter: string): void {

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

Ahora, incluso en lenguajes que admiten sobrecargas con implementaciones independientes (nota: las sobrecargas de TypeScript comparten una sola implementación), los programadores son consejos para proporcionar coherencia en los pedidos. Esto haría las firmas:

someMethod(stringParameter: string): void {

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

El stringParametersiempre se requiere, por lo que va en primer lugar. Podría escribir esto como una sobrecarga de TypeScript en funcionamiento:

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

Pero siguiendo la ley de las sobrecargas de TypeScript, podemos eliminar las firmas de sobrecarga y todas nuestras pruebas pasarán.

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

La pregunta real, en el orden real

Si estuviera decidido a persistir con el pedido original, las sobrecargas serían:

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

Eso es un montón de ramificaciones para averiguar dónde poner los parámetros, pero realmente querías preservar este orden si estás leyendo hasta aquí ... pero espera, ¿qué sucede si aplicamos la ley de sobrecargas de 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;
    }
  }
}

Suficiente ramificación ya

Por supuesto, dada la cantidad de verificación de tipos que necesitamos hacer ... tal vez la mejor respuesta sea simplemente tener dos métodos:

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

someOtherMethod(numberParameter: number, stringParameter: string): void {
  //...
}

Yo deseo. También quiero esta función, pero TypeScript debe ser interoperable con JavaScript sin tipo que no tiene métodos sobrecargados. es decir, si su método sobrecargado se llama desde JavaScript, solo se puede enviar a una implementación de método.

Hay algunas discusiones relevantes sobre el codeplex. p.ej

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

Sigo pensando que TypeScript debería generar todos los cambios y cambios para que no tengamos que hacerlo.

Por qué no utilizar la interfaz definida por propiedad opcional como argumento de función?

Para el caso de esta pregunta, el uso de una interfaz en línea definida con algunas propiedades opcionales solo podría generar directamente un código como el siguiente:

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

Debido a que la sobrecarga proporcionada en TypeScript es, como se mencionó en los comentarios de otros, solo una lista de las diferentes firmas de funciones sin admitir los códigos de implementación correspondientes como otros lenguajes estáticos. Por lo tanto, la implementación aún debe realizarse en un solo cuerpo de función, lo que hace que el uso de la sobrecarga de funciones en Typecript no sea tan cómodo como los lenguajes que admiten la función de sobrecarga real.

Sin embargo, todavía hay muchas cosas nuevas y convenientes proporcionadas en mecanografiado que no están disponibles en el lenguaje de programación heredado, donde el soporte de propiedad opcional en una interfaz anónima es un enfoque para cumplir con la zona cómoda de la sobrecarga de funciones heredadas, creo.

Si hay muchas variaciones de sobrecargas de métodos, otra forma es simplemente crear una clase con todos sus argumentos dentro. Por lo tanto, puede pasar solo el parámetro que desee en cualquier orden.

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
 }
}

También puede crear un constructor con valores predeterminados y / o pasar algunos argumentos obligatorios. Entonces solo usa así:

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

Javascript no tiene ningún concepto de sobrecarga. Typecript no es C # ni Java.

Pero puede implementar la sobrecarga en Typecript.

Lea esta publicación http://www.gyanparkash.in/function-overloading-in-typescript/