Was ist Doppelpfeilfunktion?

Question

Was ist "let x = something1 => something2 => something3"?

Ich habe diesen Code und ich verstehe nicht, was es tut.

const myReducers = {person, hoursWorked}; 
const combineReducers = reducers => (state = {}, action) => { 
    return Object.keys(reducers).reduce((nextState, key) => { 
    nextState[key] = reducers[key](state[key], action); 
    return nextState; 
    }, {}); 
}; 

Der vollständige Code einhüllen Sie brauchen:

//Redux-Style Reducer 
const person = (state = {}, action) => { 
    switch(action.type){ 
    case 'ADD_INFO': 
     return Object.assign({}, state, action.payload) 
    default: 
     return state; 
    } 
} 

const infoAction = {type: 'ADD_INFO', payload: {name: 'Brian', framework: 'Angular'}} 
const anotherPersonInfo = person(undefined, infoAction); 
console.log('***REDUX STYLE PERSON***: ', anotherPersonInfo); 

//Add another reducer 
const hoursWorked = (state = 0, action) => { 
    switch(action.type){ 
    case 'ADD_HOUR': 
     return state + 1; 
    case 'SUBTRACT_HOUR': 
     return state - 1; 
    default: 
     return state; 
    } 
} 
//Combine Reducers Refresher 

****HERE**** 
****HERE**** 
****HERE**** 

const myReducers = {person, hoursWorked}; 
const combineReducers = reducers => (state = {}, action) => { 
    return Object.keys(reducers).reduce((nextState, key) => { 
    nextState[key] = reducers[key](state[key], action); 
    return nextState; 
    }, {}); 
}; 


**** 
**** 


/* 
This gets us most of the way there, but really want we want is for the value of firstState and secondState to accumulate 
as actions are dispatched over time. Luckily, RxJS offers the perfect operator for this scenario., to be discussed in next lesson. 
*/ 
const rootReducer = combineReducers(myReducers); 
const firstState = rootReducer(undefined, {type: 'ADD_INFO', payload: {name: 'Brian'}}); 
const secondState = rootReducer({hoursWorked: 10, person: {name: 'Joe'}}, {type: 'ADD_HOUR'}); 
console.log('***FIRST STATE***:', firstState); 
console.log('***SECOND STATE***:', secondState); 

Von: https://gist.github.com/btroncone/a6e4347326749f938510

Answer 1

let x = something1 => something2 => something3 ist fast die gleiche wie die folgenden:

let x = function (something) { 
 
    return function (something2) { 
 
    return something3 
 
    } 
 
}

Der einzige Unterschied ist, Pfeile lexikalische Bindung von this haben, dh die Bindung in der Kompilierung Zeit.

Answer 2

Ein Pfeil Funktion

someParameters => someExpression 

Also, was

someParameters => someThing => someThingElse 

ist

???

Nun, durch einfaches dummes "Pattern-Matching", es ist ein Pfeil Funktion, deren Körper (someExpression) ist

someThing => someThingElse 

Mit anderen Worten, es ist

someParameters => someOtherParameters => someExpression 

Es gibt nichts besonderes über diese. Funktionen sind Objekte, sie können von Funktionen zurückgegeben werden, unabhängig davon, ob diese Funktionen mit Pfeilen oder dem Schlüsselwort function geschrieben wurden.

Das einzige, was Sie wirklich wissen müssen, um diese richtig zu lesen ist, dass der Pfeil rechts-assoziativ ist, IOW, dass

a => b => c === a => (b => c) 

---

Hinweis: Ein Pfeil Funktion kann auch einen Körper von Aussagen aus sowie einen einzelnen Ausdruck. Ich habe mich speziell auf die Form bezogen, über die das OP verwirrt ist.