Es allí una manera de hacer la sobrecarga de método en el Manuscrito?

StackOverflow https://stackoverflow.com//questions/12688275

Pregunta

Es allí una manera de hacer la sobrecarga de método en la Transcripción del lenguaje?

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í está un ejemplo de lo que no quiero hacer (yo realmente odio esa parte de la sobrecarga de hack 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);
¿Fue útil?

Solución

De acuerdo con la especificación, TyperScript utiliza la sobrecarga del método de soporte, pero es bastante incómodo e incluye un montón de tipos de parámetros de verificación de trabajo manual.Creo que es principalmente porque lo más cercano puede llegar a la sobrecarga de métodos en JavaScript simple incluye que la comprobación también, y escribió, intenta no modificar los organismos de métodos reales para evitar cualquier costo de rendimiento de tiempo de ejecución innecesario.

Si lo entiendo correctamente, primero debe escribir una declaración de método para cada una de las sobrecargas y luego la implementación de un método que comprueba 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);
    }
}

Otros consejos

Actualización para mayor claridad.La sobrecarga de métodos en el Manuscrito es una característica útil en la medida en que le permite crear definiciones de los tipos de bibliotecas existentes con una API que necesita ser representado.

Al escribir su propio código, sin embargo, usted puede ser capaz de evitar la sobrecarga cognitiva de las sobrecargas de uso opcional o parámetros por defecto.Esta es la más legible alternativa al método de sobrecargas y también mantiene su API honesto como vas a evitar la creación de sobrecargas con poco intuitivo el pedido.

La ley general de Transcripción sobrecargas es:

Si puedes eliminar la sobrecarga de firmas y todos los de su fase de pruebas, usted no necesita Manuscrito sobrecargas

Generalmente, usted puede lograr lo mismo con opcional, o los parámetros por defecto - o con tipos de unión, o con un poco de orientación a objetos.

La Pregunta

La pregunta pide una sobrecarga de:

someMethod(stringParameter: string): void {

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

Ahora incluso en idiomas que admiten sobrecargas con implementaciones independientes (nota:Transcripción de las sobrecargas compartir una única aplicación) - programadores son consejos para garantizar la coherencia en la ordenación.Esto haría que las firmas:

someMethod(stringParameter: string): void {

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

El stringParameter siempre es necesaria, así que va por primera vez.Podría escribir esto como un trabajo Mecanografiado de sobrecarga:

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 la Transcripción de las sobrecargas, podemos eliminar la sobrecarga de firmas y todas nuestras pruebas todavía va a pasar.

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

La Pregunta, En el Orden Real

Si usted se determinaron a persistir con el original de la orden, las sobrecargas sería:

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

Ahora que es un montón de ramificación que poner los parámetros, pero lo que realmente quería conservación de este orden, si usted está leyendo esto ahora...pero espera, ¿qué sucede si aplicamos la ley de Transcripción sobrecargas?

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 comprobación de tipo tenemos que hacer...quizás la mejor respuesta es simplemente para tener de dos métodos:

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

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

deseo.También quiero esta función, pero TypingScript debe ser interoperable con JavaScript sin impecación, lo que no tiene métodos sobrecargados.I.E. Si se llama a su método sobrecargado de JavaScript, solo se puede enviar a una implementación de un método.

Hay algunas discusiones relevantes sobre CODEPLEX.p.ej.

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

Todavía pienso en Typycript debería generar todo el "HIJO Y CAMBIO, así que no tendríamos que hacerlo.

¿Por qué no usar Interfaz de propiedad opcional definida como El argumento de la función ..

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

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 TIPSIPT es, como se menciona en los comentarios de otros, solo una lista de las diferentes firmas de la función sin soportar códigos de implementación correspondientes como otros idiomas estáticos. Por lo tanto, la implementación aún debe realizarse en un solo cuerpo de funciones, lo que hace que el uso de la sobrecarga de la función en TypeScript no sea tan cómoda como los idiomas que soportan la función de sobrecarga real.

Sin embargo, todavía hay muchas cosas nuevas y convenientes que se proporcionan en TyperScript que no está disponible en lenguaje de programación heredado, donde el soporte de propiedades opcionales en una interfaz anónima es un enfoque para satisfacer la zona cómoda de la función de la función heredada, creo .

JavaScript no tiene ningún concepto de sobrecarga.TypScript no es C # o Java.

Pero puede implementar la sobrecarga en TypeScript.

Leer este post http://www.gyanparkash.in/function-overloading-in-typescript/

Licenciado bajo: CC-BY-SA con atribución
No afiliado a StackOverflow
scroll top