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


109

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

1
Sí, existe la posibilidad, el idioma aún no ha muerto. ¿Alguna pregunta más?
hakre

6
@hakre Eso es algo extraño de decir, considerando que TypeScript ya admite la sobrecarga de métodos.
svick

@svick: bueno, ¿llamas a ese método sobrecarga? En su respuesta, el método en sí no está sobrecargado, un cuerpo está dando vueltas.
hakre

2
@hakre La especificación lo llama sobrecarga de métodos. Ciertamente puede argumentar que no es una versión particularmente agradable, pero creo que no puede decir que no existe en absoluto.
svick

@svick: Yo tampoco dije. Pero me parece que las posibilidades sobre las que OP pregunta son específicas sobre el modelo mental de sobrecarga de métodos. Para la división del cabello, podríamos decir que es una sobrecarga de firma del método;)
hakre

Respuestas:


165

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

3
@NicoVanBelle JavaScript no admite la sobrecarga de métodos en absoluto, ¿verdad? Entonces, ¿cómo va a ayudar volver a JS?
svick

¿Qué pasa con la verificación de interfaces? ¿Tiene una solución mejor que esa: stackoverflow.com/questions/14425568/… ?
DiPix

hmm ... realmente no me gusta esto, solo tener un parámetro opcional en su lugar es mejor para leer.
LuckyLikey

3
Creo que lo importante aquí es que mantiene su código legible sin un montón de comprobaciones de tipo if. A quién le importa en qué se transpile.
Brain2000

34

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 {
  //...
}

que comúnmente no se conoce como sobrecarga de métodos. también vea la pregunta, el tipo del primer parámetro cambia.
hakre

3
Reconocí que en mi respuesta, pondría el parámetro opcional al final, por lo que el numberparámetro sería el segundo argumento y sería opcional. TypeScript no admite sobrecargas de métodos "adecuados", pero incluso el mundo de C # se está alejando de las sobrecargas hacia parámetros opcionales, ya que en muchos casos conduce a un código más legible.
Fenton

Quieres decir if (typeof numberParameter != 'undefined'), verdad;)
Juan Mendes

Eso depende de su caso de uso, en particular si acepta ceros. Si necesita hacerlo, recuerde usarlo !==para evitar hacer malabares.
Fenton

1
@Sebastian eso suena como una oportunidad para la inyección de dependencia. Dado que la sobrecarga de métodos en TypeScript implica un solo método con múltiples decoraciones, parámetros predeterminados y tipos de unión, brinde una mejor experiencia. Si los métodos difieren de formas más sustanciales, utilice una abstracción o implemente varios métodos.
Fenton

7

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.


2

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.


0

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

Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.