Puoi spiegare questa strana funzione della freccia ES6 tramite dattiloscritto?

Question

utilizzando dattiloscritto ...

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

Am I capire questo diritto? È un metodo subscribe che ottiene la funzione come argomento, di funzione tipo, e quella funzione data, riceverà un argomento di stato quando viene chiamato, quella funzione argomentata non restituirà nulla (cioè: void) ... e io sono perso sul last() =>() => void

: /?

Sean

Answer 1

E 'per una proprietà pubblica denominata subscribe che ha un tipo di (subscribeFunction: (state) => void) =>() => void;:

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

Ecco un esempio che compila:

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

Avviso primo colon - subscribe è una proprietà pubblica di un tipo di funzione, non un metodo. Aperto:

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 

Così, è possibile memorizzare una funzione nella proprietà subscribe, quindi chiamare mentre dandogli una funzione come parametro, e come risultato si otterrà un'altra funzione, che può essere successivamente chiamare:

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 per il feedback, ora che ho capito penso che sia meglio spiegato come:

pubblica sottoscrizione: (subscribeFunction: (stato) => void)

// la prima pozione è per subscribeFunction che accetta una funzione che non restituisce nulla

=>() => void;

// seconda pozione è per il sé abbonarsi verrà restituito una funzione che non restituisce nulla ... e sono d'accordo, il codice come questo dovrebbe essere più esplicito