Können Sie diese seltsame ES6-Pfeilfunktion über Typoskript erklären?

Question

Typoskript mit ...

public subscribe:(subscribeFunction:(state)=>void)=>()=>void; 

Bin ich dieses Recht zu verstehen? Es ist eine subscribe-Methode, die Funktion als ein Argument des Typs Funktion erhält, und diese Funktion gegeben, wird ein Zustandsargument erhalten, wenn sie aufgerufen wird, dass argumented Funktion nichts zurückgibt (zB: void) ... und ich bin auf dem verloren last() =>() => void

: /?

Sean

Answer 1

Es ist für eine öffentliche Eigenschaft subscribe genannt, die eine Art von (subscribeFunction: (state) => void) =>() => void; hat:

// scope 
public 
// name 
subscribe: 
// type (function) 
    // parameters 
    (
     // parameter name 
     subscribeFunction: 
     // parameter type (function) 
     (state) => void 
    ) => 
    // return type (function) 
    () => void; 

Hier ist ein Beispiel, das kompiliert:

class MyClass { 
    public subscribe: (subscribeFunction: (state) => void) =>() => void; 
} 

let myInstance = new MyClass(); 

myInstance.subscribe = (subscribeFunction: (state) => void) => { 
    console.log("statements might go here"); 

    return() => { 
     subscribeFunction(1 /* state */); 
     console.log("nothing returned by this inner function"); 
    }; 
}; 

// Example use 

// outputs "statements might go here" 
let innerFunction = myInstance.subscribe((state) => console.log(state)); 
// outputs 1 and "nothing returned by this inner function" 
innerFunction(); 

Answer 2

Mitteilung über den ersten Doppelpunkt - subscribe ist eine öffentliche Eigenschaft eines Funktionstyps, keine Methode. Entfaltete:

public subscribe: // public property, which is 
    (// of the type of a function, which takes 
     subscribeFunction: // 1 parameter, which itself is 
     (state) => void // a function of 1 parameter, returning nothing 
    ) => // and the upon invocation of a function stored in "subscribe" it 
     () => void; // returns a function of no parameter and no return value 

So eine Funktion in die subscribe Eigenschaft speichern kann, dann rufen Sie während es eine Funktion als Parameter übergeben wird, und als Ergebnis erhalten Sie eine weitere Funktion erhalten, die Sie anschließend anrufen:

subscribe = (subscribeFunction: (state) => void) => { 
    subscribeFunction('A'); 
    return() => {console.log('C');}; 
}; 
let subscribed = subscribe((state) => { 
    console.log(state, 'B'); 
}); // prints 'A,B' 
subscribed(); // prints 'C' 

Answer 3

tx für Feedback, jetzt, wo ich es verstehe ich denke, daß seine besten erklärt wie:

öffentlich abonnieren: (subscribeFunction: (state) => void)

// Der erste Trank ist für subscribeFunction, der eine Funktion akzeptiert, die nichts zurückgibt

=>() => void;

// zweite Trank ist für die selbst abonnieren, da es eine Funktion zurück, die nichts zurückliefert ... und ich stimme zu, Code wie diesen sollte