Oct 25, 2017 · 7 min read

Functional programming is a highly valued approach to writing code, and it’s popularity is continuously increasing in kereskedelmi szoftver alkalmazások. A funkcionális programozás a kód írásának paradigmája, és ékesszólóan szerepel a Wikipédia cikk bevezetésében:

” – a számítógépes programok szerkezetének és elemeinek felépítésének stílusa -, amely a számítást matematikai függvények értékeléseként kezeli, és elkerüli a változó állapotú és változékony adatokat. Ez egy deklaratív programozási paradigma, ami azt jelenti, hogy a programozás kifejezések vagy nyilatkozatok helyett történik.”

hamarosan belemerülünk abba, amit ez pontosan jelent, de először vegyük ki az alapokat az útból valamilyen kontextus biztosításával. Ez a cikk azt a célt szolgálja, remélhetőleg bemutatkozik az alapvető fogalmakat, a funkcionális programozási, hogy te, meg a végén, mi volna létre egy alapvető megértése, hogy miért kellene úgy dönt, hogy alkalmazza be a kódolási stílusok, hogyan kapcsolódik a JavaScript néhány alapvető mintákat, hogy kezdhetjük végrehajtási be a kódot. Keressen egy második cikket, amely erre épül, és még mélyebben belemerül az itt tárgyalt ötletekbe.

a funkcionális programozás gyökerei a Lambda kalkulusban rejlenek, amely egy olyan rendszer volt, amelyet az 1930-as években fejlesztettek ki a számítás kifejezésére olyan funkciók felhasználásával, amelyek hasonlóak ahhoz, amit hamarosan látni fogunk. Hosszú ideig a funkcionális programozási fogalmakat és nyelveket széles körben megvitatták a tudományos és tudományos kontextusban, és végül bevéreztek a kereskedelmi szoftverek fejlesztésébe. Ami a programozási nyelvet működőképessé teszi, az a funkcionális programozási paradigma megkönnyítésének képessége, az ilyen nyelvek A Ruby, a Python, A Julia és a JavaScript, amelyek közül az utóbbi rendelkezik imperatív, objektumorientált és funkcionális paradigmákkal.

nézzünk egy példát egy imperatívum használatára, majd egy funkcionális megközelítésre egyetlen feladat elvégzéséhez.

Imperative:

const arr = function getOdds(arr){
let odds = ; for(let i = 0; i < arr.length + 1; i++){
if ( i % 2 !== 0 ){
odds.push( i )
};
};
return odds
};console.log(getOdds(arr))
// logs 

Functional:

function getOdds2(arr){
return arr.filter(num => num % 2 !== 0)
}console.log(getOdds2(arr))
// logs // this can be even shorter
const getOdds3 = arr => arr.filter(num => num % 2 !== 0)console.log(getOdds3(arr))
// logs 

eltekintve a nyilvánvaló fejlesztések a funkcionális megközelítés teszi, mint a rövidebb kódot, megtakarítás nekünk egy pár billentyűleütések, és az a tény, hogy ez sokkal könnyebb megérteni egy gyors pillantásra, ez is elegáns, ami tisztább kódot, egyszerűsíti hibakeresés, tesztelés és karbantartás.

ezt bontsuk le egy kicsit, hogy világosan megértsük a két megközelítés közötti különbségeket, és meghatározzuk, mi a funkcionális programozás.

az első megközelítésben feltétlenül leírunk minden olyan eseményt, amelyre szükség van annak érdekében, hogy elérjük azt a feladatot, hogy kiszűrjük a páratlan számokat egy tömbből. Mi takarmány egy függvény egy tömb, belül a függvény létrehozunk egy üres tömb, amely fogjuk használni, hogy tárolja a páratlan számokat. Azt mondjuk, hogy hurkolja át a tömböt, majd feltételesnek nyilvánítunk, ha az aktuális index páratlan szám, tolja az üresre. A for loop nem tartalmazza az utolsó számot a tömbben, csak a hozzá vezető számokat tartalmazza, tehát ha az utolsó számunk páratlan, akkor azt nem tartalmazza. Ezért +1-et adunk hozzá, amikor meghatározzuk a hurok által elvégzendő iterációk mennyiségét.

a második megközelítésben egyszerűen definiáljuk a kívánt eredményt egy filter nevű módszerrel, majd hagyjuk, hogy a gép gondoskodjon a két lépés közötti lépésekről. Ez egy deklaratív megközelítés. Kijelentjük, hogy mi legyen a végeredmény, a többit pedig nekünk kezeljük.

most már láthatjuk,hogy a fent említett meghatározás mire törekszik. A programozás módja, nyilatkozatok és kifejezések használata, nem pedig kijelentések. Ez a definíció csak a funkcionális programozás felszínét kaparja le, és a megértésünk növekedésével folyamatosan a definíciónkra építünk.

néhány különbség az iteratív és funkcionális megközelítések között.

• stilisztikailag definiálunk egy problémát, valamint azokat a változásokat, amelyeket szeretnénk látni, szemben a lépésről lépésre történő magyarázattal.
• nem kell kezelnünk az állapotot a fentihez hasonló funkcióinkban, ahol az üres tömb állapotát kezeltük.
• nem kell annyira aggódnunk a végrehajtás sorrendje miatt.
• kevesebb hurkot, feltételt használunk, és több beépített módszert, újrafelhasználható funkciókat és rekurziót használunk.

ezzel a megközelítéssel végül tisztább kódot írunk, amely a fent említettek szerint segít a hibakeresésben és a karbantartásban. Modulárisan tartja a dolgokat, kódunk egyes részeit kisebb darabokra bontjuk, amelyeket könnyedén tesztelhetünk. A kód egyes részeit újra felhasználhatjuk segítő funkciók segítségével, végül pedig hatékonyabb, matematikai megközelítés a kód írásához.

az oszlopok: A funkcionális kód írására szolgáló kódoló eszközkészletünk

a következő néhány fontos szempont a kiváló minőségű funkcionális kód írásához. Látva, hogy ez egy áttekintés, nem fogunk túlságosan belemerülni mindegyikbe, ehelyett csak néhány kulcsfontosságú jellemzőt és mindegyikre egy példát határozunk meg.

Pure Functions:

Pure functions return a value only based on what was passed into it. Az elképzelés mögött az áll, hogy tiszta függvény lesz, ha mindig ugyanazt az eredményt adja vissza, ha ugyanazok az értékek kerülnek bele, és nem módosítja az értékeket a TS hatókörén kívül, ami függetlenné teszi a rendszer bármely állapotától. Ezért egy tiszta funkció soha nem mutálhat adatokat, nem okoz mellékhatásokat, és könnyen újra felhasználható. Egy példa a nem tiszta függvény lesz egy függvény, ami egy API hívást, vagy visszatér egy kiszámíthatatlan eredményt.

egyszerű tisztátalan funkció:

var tip = 0;function calculateTip( mealTotal ) {
tip = 0.15 * mealTotal;
}calculateTip( 150 )
console.log(tip)

egyszerű tiszta funkció:

function isPure(x,y) {
return x * y
}console.log(isPure(3,5));

a tiszta függvény minden alkalommal visszaadja a pontos eredményt, és nem mutál rajta kívül semmilyen adatot. A fontos dolog, hogy figyeljen arra, hogy a tiszta funkciónak távol kell maradnia az adatok mutációjától, ezért legyen óvatos, amikor kiválasztja, hogy mely módszereket használja a tiszta funkciókban. Például, ha két tömböt szeretne egyesíteni a függvényen belül, mint általában egy Reakciócsökkentőben, kerülje a tömb használatát.prototípus.push () módszer. Ehelyett az Array-t szeretné használni.prototípus.concat (), amely megőrzi az állam a régi tömbök, majd vissza egy újat az Ön számára.

magasabb rendű függvények:

A JavaScriptben a függvényeket objektumként kezeljük, ezért a függvényeket úgy tudjuk átadni, mint bármely más értéket. A magasabb rendű funkció egyszerűen olyan funkció, amely más funkciókon működik. Bevihetnek egy funkciót bemenetként,vagy visszaadhatnak egy kimenetet. Egy egyszerű példát fogunk látni a következő bemutatóban.

Anonymous függvények:

Anonymous függvények nagyon hasznosak, ha szükség szerint ad hoc logikát kell definiálnunk. Ahogy a neve is sugallja, egy névtelen függvény névtelen, és többnyire egy függvény argumentumaként található, mint egy megnevezett függvény helyettesítője, egy változóhoz rendelt függvény, vagy egy magasabb rendű függvényként visszaadott függvény. Gyökerei a Lambda kalkulusban rejlenek, és nagyon fontos minden funkcionális programozási nyelv számára.

változóhoz rendelt névtelen függvény. Könnyű körbejárni és hivatkozni, ha szükséges.

const myVar = function(){console.log(‘Anonymous function here!’)}myVar()

Névtelen függvény, mint érv,

setInterval(function(){console.log(new Date().getTime())}, 1000);

Névtelen függvények belül egy magasabb rendű funkció

function mealCall(meal){
return function(message){
return console.log(message + " " + meal + ‘!!’)
}
}const announceDinner = mealCall(‘dinner’)
const announceLunch = mealCall(‘breakfast’)announceDinner(‘hey!, come and get your’)
announceLunch(‘Rise and shine! time for’)

a Rekurzió

a Rekurzió egy jól ismert funkcionális programozási technika. A rekurzív függvény egyszerűen egy olyan függvény, amely önmagát hívja, ezért hurokként működik, ugyanazt a kódot többször végrehajtva. Jön egy kivétellel, bár, az egyik legyen óvatos, hogy elkerüljék a végtelen rekurziók. Ezért szükség van egy alap esetre, hogy megmondja, mikor kell abbahagyni. A rekurzív funkciók vagy algoritmusok mind rekurzióval, mind hurkokkal megvalósíthatók, de jobb a rekurzió használata. Az alábbiakban egy jól ismert algoritmus található egy szám faktorizálására mind rekurzió, mind hurok használatával.

rekurzív függvény

function factorialize(num){
if (num === 0 || num === 1){return 1;}
return (num * factorialize(num — 1));
}var result = factorialize(14);console.log(result);

rekurzió hurok segítségével

function factorialize(num) {
if (num === 0 || num === 1){
return 1;
}
for (var i = num-1; i >= 1; i-- ) {
num *= i;
}
return num;
}
console.log(factorialize(6));

a funkcionális kód írásához néhány alapvető összetevőt lefedtünk. Nem lehet mindig funkcionális kódot írni egy alkalmazásban, de az előnyök nagyszerűek, ha a lehető legnagyobb mértékben használják. Az Angular és a React keretrendszereket erősen befolyásolja a funkcionális programozás, és az olyan könyvtárak, mint a Redux és a Lodash, lehetővé teszik számunkra, hogy kihasználjuk annak előnyeit, így határozottan nagy előnye van a gondolkodásnak az FP módon.

források a további tanuláshoz? Íme néhány nagyszerű cikk és forrás a további tanuláshoz.

• miért tanulja meg a funkcionális programozást a JavaScriptben? Eric Elliot
• Ékesszóló JavaScript által Marijn Haverbeke
• Tehát azt szeretnénk, hogy egy Funkcionális Programozó által Charles Scalfani

nagyon remélem, hogy ez hasznos volt, majd a következő cikkben fogunk merülni egy kicsit mélyebbre kipakolni még több érdekes, hasznos eszközök, mint a JavaScript módszerek, részleges alkalmazás, currying, érv kötelező, valamint több.

nyugodtan tapsoljon, ossza meg, kritizálja vagy ossza meg gondolatait a témáról!