Tiszta függvények a JavaScriptben és létrehozásuk

A tiszta függvények olyan függvények, amelyek nem okoznak mellékhatásokat, és ha ugyanazokkal a bemeneti paraméterekkel hívják meg, mindig ugyanazt a kimenetet adják vissza.

Tiszta függvényekkel biztosíthatja, hogy kódja tiszta, karbantartható és tesztelhető legyen. Ezek a függvények ideálisak ezekhez a feladatokhoz, mert kiszámíthatóak és nem módosítják a külső állapotokat.

Könnyebb a hibakeresésük is, így hasznosak lehetnek összetett szoftverrendszerek fejlesztésében. Itt megismerheti a JavaScript tiszta funkcióit, azok jellemzőit és előnyeit.

A tiszta függvény jellemzői

Mert egy funkciót hogy „tiszta” legyen, néhány követelménynek meg kell felelnie.

Állandó megtérülési érték

A tiszta függvénynek mindig ugyanazt az értéket kell visszaadnia ugyanazzal a bemenettel, függetlenül attól, hogy hányszor hívják meg.

Vegyük például az alábbi függvényt:

funkciószaporodnak(a, b) {
Visszatérés a * b;
}

A szaporodnak függvény a fenti példában mindig a két argumentuma szorzatát adja vissza. Ugyanazon argumentumkészlet mellett állandó visszatérési értéke van.

Ha ezt a függvényt többször ugyanazokkal az argumentumokkal hívjuk meg, akkor minden alkalommal ugyanazt a kimenetet kapjuk. Például:

szoroz(2, 3); // 6-ot adja vissza
szoroz(2, 3); // 6-ot adja vissza
szoroz(2, 3); // 6-ot adja vissza

Alternatív megoldásként vegye figyelembe az alábbi példát:

funkciómultiplyRandomNumber(sz) {
Visszatérés szám * Math.padló(Math.random() * 10);
}
multiplyRandomNumber(5); // Megjósolhatatlan eredmények
multiplyRandomNumber(5); // Megjósolhatatlan eredmények
multiplyRandomNumber(5); // Megjósolhatatlan eredmények

A multiplyRandomNumber A fenti függvény minden egyes meghívásakor más eredményt ad, így tisztátalanná válik. Ennek a függvénynek az eredményei megjósolhatatlanok, így a rá támaszkodó komponensek tesztelése nehézkes.

Nincs mellékhatás

Egy tiszta funkció nem okozhat semmilyen mellékhatást. A mellékhatás az állapot vagy a viselkedés bármely, a függvény hatókörén kívüli módosítására utal, mint például a globális változók, a konzolkimenet, a hálózati kérések vagy a DOM-manipuláció módosítása.

Ha egy tiszta funkciónak van mellékhatása, az már nem tiszta, mert befolyásolja a külső állapotot, és sérti azt az elvet, hogy nincsenek megfigyelhető mellékhatásai. Ezért a tiszta függvények elkerülik a mellékhatásokat, hogy ne változtassák meg a program állapotát.

Vegyük például az alábbi példát:

hagyja szám = 0;
funkciónövekedés() {
 count++;
konzol.log (számlálás);
}
növekedés(); // Naplók 1
növekedés(); // Naplók 2
növekedés(); // Naplók 3

A növekedés A függvény ebben a példában azzal a mellékhatással jár, hogy módosítja a számol hatályán kívül eső változó. A konzolra is bejelentkezik.

Ez a funkció nem tiszta, mert van egy mellékhatása, ami megnehezítheti a kimenetének előrejelzését és az elkülönített tesztelést. Ahhoz, hogy tiszta legyen, módosíthatja úgy, hogy a számol változót argumentumként, és visszaadja a megnövelt értéket anélkül, hogy bármilyen külső állapotot módosítana.

Például így:

funkciónövekedés(számol) {
Visszatérés számol + 1;
}
növekedés(1); // visszaadja a 2-t
növekedés(1); // visszaadja a 2-t
növekedés(1); // visszaadja a 2-t

A verzió a növekedés A fenti példában szereplő függvénynek nincs mellékhatása, mivel nem módosít semmilyen külső változót és nem naplóz semmilyen értéket. Ezenkívül, függetlenül attól, hogy hányszor hívja meg, ugyanazt az értéket adja vissza ugyanahhoz a bemenethez. Ezért ez egy tiszta funkció.

Egyéb jellemzők

Amellett, hogy állandó visszatérési értéke van, és nem okoz semmilyen mellékhatást, be kell tartania a következő szabályokat, amikor JavaScript függvény létrehozása hogy tiszta akarsz lenni:

• A függvény nem módosíthatja egyetlen argumentumát sem. Ehelyett, ha bármely művelet mutációt igényel, készítsen másolatot az argumentumról, és mutassa meg a másolatot.
• A függvénynek mindig visszatérési értékkel kell rendelkeznie. Ha a függvényednek nincs visszatérési értéke vagy nincs mellékhatása, akkor nem tud semmit!
• A funkciója nem függhet semmilyen külső állapottól.

A Pure Functions előnyei

A tiszta függvényeknek vannak bizonyos előnyei a szennyezett függvényekkel szemben, amelyek közül néhány a következőket tartalmazza.

Tesztelhetőség

A tiszta függvények könnyen tesztelhetők, mivel bemeneti/kimeneti viselkedésük jól meghatározott. Ezenkívül a tiszta funkciók nem függnek a külső állapottól vagy a mellékhatásoktól. Ezért elkülönítve tesztelheti őket anélkül, hogy aggódnia kellene a függőségek vagy a program más részeivel való interakciók miatt.

Ezzel szemben a külső állapottól függő vagy mellékhatásokat kiváltó szennyezett függvények tesztelése nagyobb kihívást jelenthet, mivel viselkedésük a program állapotától vagy más külső tényezőktől függhet. Ez megnehezítheti átfogó tesztesetek létrehozását, és biztosíthatja, hogy a függvény minden forgatókönyvben megfelelően működjön.

Memoizáció

Mivel a tiszta függvények mindig ugyanazt a kimenetet állítják elő ugyanahhoz a bemenethez, és nem okoznak mellékhatásokat, könnyen megjegyezheti őket.

Ezekre a tulajdonságokra támaszkodva és a memoizáció használatával gyorsítótárazhatja egy adott bemenethez tartozó tiszta függvényhívás eredményét. A függvény ezután visszaadhatja a gyorsítótárazott eredményt, amikor legközelebb ugyanazzal a bemenettel hívja meg.

Tiszta funkciók memorizálása javíthatja a program teljesítményét, különösen olyan drága számítások esetén, amelyek ismétlődően ugyanazt a bemenetet kezelik, anélkül, hogy aggódnának a program állapotával való interferencia miatt.

Ezzel szemben a szennyezett függvények ugyanarra a bemenetre eltérő eredményeket produkálhatnak, a program állapotától vagy külső tényezőktől függően. Emiatt nehéz megjegyezni őket, mert előfordulhat, hogy a gyorsítótárazott eredmény már nem érvényes, ha a függvény függőségei vagy külső állapota megváltozik a hívások között.

Egyidejűség

Mivel a tiszta függvények nem módosítanak semmilyen külső állapotot és nem okoznak mellékhatásokat, szálbiztosak. Egyidejűleg is futtathatja őket anélkül, hogy aggódnia kellene a versenyfeltételek vagy a szinkronizálási problémák miatt.

Ezzel szemben a szennyezett függvények párhuzamos végrehajtása kihívást jelenthet, mivel zavarhatják egymást, vagy nem várt viselkedést idézhetnek elő párhuzamos végrehajtáskor. Például, ha két szál ugyanahhoz a globális változóhoz fér hozzá és módosítja azt, akkor felülírhatják egymás módosításait, vagy következetlen eredményeket produkálhatnak.

Pure Functions vs. Tiszta funkciók

Programokat írhat tiszta és tisztátalan függvények kombinációjával, mivel minden típusnak megvan a maga használata.

A tiszta függvények könnyen optimalizálhatók, tesztelhetők és párhuzamosíthatók, így alkalmasak olyan használati esetekre, mint a funkcionális programozás, gyorsítótár, tesztelés, párhuzamos programozás és adatfeldolgozási feladatok.

A tisztátalan függvények azonban kihívásokat jelentenek a tesztelés és a párhuzamosság terén, de hasznosak változtatható adatstruktúrákkal való munkavégzéskor vagy külső rendszerekkel és erőforrásokkal való interakció során.