arrays - programacion - En TypeScript, ¿cómo declaro una matriz de funciones que aceptan una cadena y devuelven una cadena?

que es un array

Question

ACTUALIZACIÓN : el contexto de esta pregunta fue pre-TypeScript 1.4. Desde esa versión, mi primera suposición ha sido respaldada por el lenguaje. Ver la actualización de la respuesta.

Puedo declarar que f es una función que acepta una cadena y devuelve una cadena:

var f : (string) => string

Y puedo declarar que g es una matriz de cadenas:

var g : string[]

¿Cómo puedo declarar que h es una matriz de "función que acepta una cadena y devuelve una cadena"?

Mi primera suposición:

var h : ((string) => string)[]

Eso parece ser un error de sintaxis. Si elimino los paréntesis adicionales, se trata de una función de cadena a matriz de cadena.

Answer 1

Basado en su investigación, escribí una pequeña clase PlanetGreeter / SayHello: `

/* PlanetGreeter */
class PlanetGreeter {
hello : { () : void; } [] = [];
planet_1 : string = "World";
planet_2 : string = "Mars";
planet_3 : string = "Venus";
planet_4 : string = "Uranus";
planet_5 : string = "Pluto";
constructor() {
this.hello.push( () => { this.greet(this.planet_1); } );
this.hello.push( () => { this.greet(this.planet_2); } );
this.hello.push( () => { this.greet(this.planet_3); } );
this.hello.push( () => { this.greet(this.planet_4); } );
this.hello.push( () => { this.greet(this.planet_5); } );
}
greet(a: string): void { alert("Hello " + a); }
greetRandomPlanet():void {
this.hello [ Math.floor( 5 * Math.random() ) ] ();
}
}
new PlanetGreeter().greetRandomPlanet();

Answer 2

Me lo imaginé. El problema es que el => para un tipo de función literal es en sí mismo meramente azúcar sintáctico y no quiere componer con [] .

Como dice la especificación:

Un tipo de función literal de la forma

(ParamList) => ReturnType

es exactamente equivalente al tipo de objeto literal

{(ParamList): ReturnType}

Entonces, lo que quiero es:

var h : { (s: string): string; }[]

Ejemplo completo:

var f : (string) => string
f = x => ''('' + x + '')'';
var h : { (s: string): string; }[]
h = [];
h.push(f);

Actualización :

A juzgar por este conjunto de cambios , se permitirán paréntesis en las declaraciones de tipo en 1.4, por lo que la "primera suposición" en la pregunta también será correcta:

var h: ((string) => string)[]

Actualización adicional ¡ Está en 1.4!