c# - overload - Declarar un tipo de delegado en Typescript

typescript string vs string

Question

Procedente de un fondo de C #, quiero crear un tipo de datos que defina una firma de función. En C #, este es un delegate declarado así:

delegate void Greeter (string message);

public class Foo
{
    public void SayHi (Greeter g) {
        g("Hi!");
    }
}

Ahora, quiero lograr algo similar en Typescript. Sé que Typescript no tiene tipos de delegados, sino solo lambdas. Se me ocurrió algo como esto:

class Foo {
    SayHi (greeter: (msg: String) => void) {
        greeter(''Hi!'');
    }
}

Mientras esto funciona, quiero reutilizar la firma del método (msg:String) => void par de veces y creo que sería más limpio crear un tipo personalizado, como el delegado en C #.

¿Alguna idea de cómo se puede hacer esto?

Answer 1

Ahora publico y uso @steelbreeze/delegate ; tiene algunas limitaciones en comparación con el delegado de C #, ya que es inmutable, pero de lo contrario funciona bien (y cuando se llama devuelve resultados de todas las funciones llamadas).

Te permite escribir código como:

import { create as delegate } from "@steelbreeze/delegate";

function world(s: string) {
    console.log(s + " world");
}

const one = delegate(s => console.log(s + " Hello world"));
const two = delegate(s => console.log(s + " Hello"), world);

one("A");
two("B");

delegate(one, two)("C");

Answer 2

En TypeScript, las interfaces pueden tener firmas de llamada. En tu ejemplo, podrías declararlo así:

interface Greeter {
    (message: string): void;
}

function sayHi(greeter: Greeter) {
    greeter(''Hello!'');
}

sayHi((msg) => console.log(msg)); // msg is inferred as string

Answer 3

Puede crear algo así como un delegado como este:

type MyDelegate = (input: string) => void;

que define un nombre de tipo para un puntero de función, tal como lo hacen los delegados en C #. El siguiente ejemplo lo usa en combinación con parámetros genéricos de tipo:

type Predicate<T> = (item: T) => boolean;

export class List<T> extends Array<T> {
    constructor(...items: T[]){
        super();
        for(let i of items || []){
            this.push(i);
        }
    }
    public hasAny(predicate?: Predicate<T>): boolean {
        predicate = predicate || (i => true)
        for(let item of this) {
            if(predicate(item)) return true;
        }
        return false;
    }
}

Answer 4

Tipo de definición para una expresión invocable (este es un borrador correcto, para humanos ... no es un BNF ni nada formal) :

callableType: (paramsDef) => returnType

paramsDef:    MULTIPLE paramDef SEPARATED BY ,

paramDef:     EITHER   paramName: paramType
                  OR   optionalParamName?: paramTypeWhenDefined
                  OR   ...manyParamName: eachParamType[]

Ejemplo:

var func = something as ((...x: any[]) => any);

Entonces tú puedes:

var result = func("a", "b", 2);