Sobrecarga de la función TypeScript

Este enunciado ha sido analizado por especialistas así se asegura la exactitud de nuestra esta división.

Solución:

Cuando sobrecarga TypeScript, solo tiene una implementación con varias firmas.

class Foo 
    myMethod(a: string);
    myMethod(a: number);
    myMethod(a: number, b: string);
    myMethod(a: any, b?: string) 
        alert(a.toString());
    

TypeScript reconoce solo las tres sobrecargas como posibles firmas para una llamada de método, no la implementación real.

En su caso, yo personalmente usaría dos métodos con nombres diferentes ya que no hay suficientes parámetros en común, lo que hace que sea probable que el cuerpo del método necesite tener muchos “si” para decidir qué hacer.

Mecanografiado 1.4

A partir de TypeScript 1.4, normalmente puede eliminar la necesidad de una sobrecarga utilizando un tipo de unión. El ejemplo anterior se puede expresar mejor usando:

myMethod(a: string | number, b?: string) 
    alert(a.toString());

El tipo de a es cualquiera string o number“.

Esto puede deberse a que, cuando ambas funciones se compilan en JavaScript, su firma es totalmente idéntica. Como JavaScript no tiene tipos, terminamos creando dos funciones que toman la misma cantidad de argumentos. Entonces, TypeScript nos restringe de crear tales funciones.

TypeScript admite la sobrecarga en función de la cantidad de parámetros, pero los pasos a seguir son un poco diferentes si los comparamos con los lenguajes OO. En respuesta a otra pregunta de SO, alguien lo explicó con un buen ejemplo: ¿Sobrecarga de métodos?

Básicamente, lo que estamos haciendo es crear solo una función y varias declaraciones para que TypeScript no produzca errores de compilación. Cuando este código se compila en JavaScript, solo la función concreta será visible. Como se puede llamar a una función de JavaScript pasando múltiples argumentos, simplemente funciona.

Puede declarar una función sobrecargada declarando que la función tiene un tipo que tiene múltiples firmas de invocación:

interface IFoo

    bar: 
        (s: string): number;
        (n: number): string;
    

Entonces lo siguiente:

var foo1: IFoo = ...;

var n: number = foo1.bar('baz');     // OK
var s: string = foo1.bar(123);       // OK
var a: number[] = foo1.bar([1,2,3]); // ERROR

El actual definición de la función debe ser singular y realizar internamente el despacho apropiado sobre sus argumentos.

Por ejemplo, usando una clase (que podría implementar IFoopero no tiene que hacerlo):

class Foo

    public bar(s: string): number;
    public bar(n: number): string;
    public bar(arg: any): any 
    
        if (typeof(arg) === 'number')
            return arg.toString();
        if (typeof(arg) === 'string')
            return arg.length;
    

Lo interesante aquí es que el any la forma es oculto por las anulaciones tipeadas más específicamente.

var foo2: new Foo();

var n: number = foo2.bar('baz');     // OK
var s: string = foo2.bar(123);       // OK
var a: number[] = foo2.bar([1,2,3]); // ERROR

Tienes la opción de añadir valor a nuestro contenido informacional colaborando tu veteranía en las críticas.

---

---

Utiliza Nuestro Buscador