Funkcióösszetétel a JavaScript-ben

A függvényösszetétel az egyik függvény pontszerű alkalmazása a másik eredményére. A fejlesztők minden nap manuálisan csinálják, amikor a fészek működik:

compose = (fn1, fn2) => value => fn2(fn1(value))

De ezt nehéz elolvasni. Van egy jobb módszer a funkciókompozíció használatára. Ahelyett, hogy kívülről olvasnád őket:

add2AndSquare = (n) => square(add2(n))

Használhatunk magasabb rendű függvényt, hogy rendezett módon láncoljuk őket.

add2AndSquare = compose( add2, square)

A szövegírás egyszerű megvalósítása a következő lenne:

compose = (f1, f2) => value => f2( f1(value) );

A még nagyobb rugalmasság érdekében használhatjuk a reducRight funkciót:

compose = (...fns) => (initialVal) => fns.reduceRight((val, fn) => fn(val), initialVal);

A szövegírás balról jobbra olvasása lehetővé teszi a magasabb rendű funkciók egyértelmű láncolását. A valós világ példái a hitelesítések, a naplózás és a kontextus tulajdonságok hozzáadása. Ez egy olyan technika, amely lehetővé teszi az újrafelhasználhatóságot a legmagasabb szinten. Íme néhány példa a használatára:

// example const add2 = (n) => n + 2; const times2 = (n) => n * 2; const times2add2 = compose(add2, times2); const add6 = compose(add2, add2, add2); times2add2(2); // 6 add2tiems2(2); // 8 add6(2); // 8

Azt gondolhatja, hogy ez fejlett funkcionális programozás, és nem releváns a frontend programozás szempontjából. De hasznos az Egyoldalas alkalmazásokban is. Például hozzáadhat viselkedést a React összetevőhöz magasabb rendű összetevők használatával:

function logProps(InputComponent) { InputComponent.prototype.componentWillReceiveProps = function(nextProps) { console.log('Current props: ', this.props); console.log('Next props: ', nextProps); }; return InputComponent; } // EnhancedComponent will log whenever props are received const EnhancedComponent = logProps(InputComponent);

Összefoglalva, a függvényösszetétel lehetővé teszi a funkcionalitás újrafelhasználhatóságát nagyon magas szinten. Ha a funkciók jól fel vannak strukturálva, ez lehetővé teszi a fejlesztők számára, hogy új viselkedést alkossanak a meglévő viselkedés alapján.

Ez növeli a megvalósítások olvashatóságát is. A fészkelési funkciók helyett egyértelműen láncolhatja a funkciókat, és magasabb rendű függvényeket hozhat létre értelmes nevekkel.