Werken met pure functies kan een stuk minder stressvol zijn, omdat je ze gemakkelijk kunt testen en er met meer vertrouwen over kunt redeneren.

Pure functies zijn functies die geen neveneffecten produceren en die, wanneer ze worden aangeroepen met dezelfde invoerparameters, altijd dezelfde uitvoer teruggeven.

U kunt pure functies gebruiken om ervoor te zorgen dat uw code schoon, onderhoudbaar en testbaar is. Deze functies zijn ideaal voor deze taken omdat ze voorspelbaar zijn en externe toestanden niet wijzigen.

Ze zijn ook gemakkelijker te debuggen, waardoor ze nuttig zijn bij het ontwikkelen van complexe softwaresystemen. Hier verken je pure functies in JavaScript, hun kenmerken en hun voordelen.

Kenmerken van een pure functie

Voor een functie om “puur” te zijn, moet het aan een aantal eisen voldoen.

Constante retourwaarde

Een zuivere functie moet altijd dezelfde waarde retourneren bij dezelfde invoer, ongeacht het aantal keren dat deze wordt aangeroepen.

Beschouw bijvoorbeeld de onderstaande functie:

functievermenigvuldigen(een, b) {
opbrengst een * b;
}

De vermenigvuldigen functie in het bovenstaande voorbeeld zal altijd het product van zijn twee argumenten teruggeven. Gegeven dezelfde set argumenten, heeft het een constante retourwaarde.

Als u deze functie meerdere keren aanroept met dezelfde argumenten, krijgt u elke keer dezelfde uitvoer. Bijvoorbeeld:

vermenigvuldigen(2, 3); // retourneert 6
vermenigvuldigen(2, 3); // retourneert 6
vermenigvuldigen(2, 3); // retourneert 6

Bekijk anders het onderstaande voorbeeld:

functievermenigvuldigenRandomNumber(aantal) {
opbrengst aantal * Wiskunde.vloer(Wiskunde.willekeurig() * 10);
}
vermenigvuldigenWillekeurigGetal(5); // Onvoorspelbare resultaten
vermenigvuldigenWillekeurigGetal(5); // Onvoorspelbare resultaten
vermenigvuldigenWillekeurigGetal(5); // Onvoorspelbare resultaten

De vermenigvuldigenRandomNumber functie hierboven zal elke keer dat u hem aanroept verschillende resultaten retourneren, waardoor hij onzuiver wordt. De resultaten van deze functie zijn onvoorspelbaar, dus het testen van componenten die ervan afhankelijk zijn, is moeilijk.

Geen bijwerkingen

Een pure functie mag geen bijwerkingen veroorzaken. Een neveneffect verwijst naar elke wijziging van de status of het gedrag buiten het bereik van de functie, zoals het wijzigen van globale variabelen, console-uitvoer, netwerkverzoeken of DOM-manipulatie.

Wanneer een zuivere functie een neveneffect heeft, is het niet langer zuiver omdat het de externe toestand beïnvloedt en in strijd is met het principe dat er geen waarneembare neveneffecten zijn. Daarom vermijden pure functies bijwerkingen om ervoor te zorgen dat ze de status van het programma niet veranderen.

Beschouw bijvoorbeeld het onderstaande voorbeeld:

laten tel = 0;
functieverhoging() {
 tel++;
troosten.log (aantal);
}
verhoging(); // Logboeken 1
verhoging(); // Logboeken 2
verhoging(); // Logboeken 3

De verhoging functie in dit voorbeeld heeft het neveneffect van het wijzigen van de graaf variabele buiten zijn bereik. Het logt ook in op de console.

Deze functie is niet zuiver omdat het een neveneffect heeft, waardoor het moeilijker kan zijn om de output te voorspellen en afzonderlijk te testen. Om het puur te maken, kun je het aanpassen om het op te nemen graaf variabele als een argument en retourneert de opgehoogde waarde zonder een externe status te wijzigen.

Zoals zo:

functieverhoging(graaf) {
opbrengst tel + 1;
}
verhoging (1); // retourneert 2
verhoging (1); // retourneert 2
verhoging (1); // retourneert 2

De versie van de verhoging functie in het bovenstaande voorbeeld heeft geen neveneffecten omdat het geen enkele externe variabele wijzigt of een waarde registreert. Bovendien, het maakt niet uit hoe vaak u het aanroept, het retourneert dezelfde waarde voor dezelfde invoer. Daarom is het een pure functie.

Andere kenmerken

Naast het hebben van een constante retourwaarde en het niet produceren van bijwerkingen, moet u zich aan de volgende regels houden wanneer u dat bent een JavaScript-functie maken dat je puur wilt zijn:

  • Uw functie mag geen van zijn argumenten wijzigen. In plaats daarvan, als een bewerking mutatie vereist, maak dan een kopie van het argument en muteer de kopie.
  • Uw functie moet altijd een retourwaarde hebben. Als uw functie geen retourwaarde of neveneffecten heeft, kan deze niets doen!
  • Uw functie mag niet afhankelijk zijn van enige externe toestand.

Voordelen van Pure Functions

Zuivere functies hebben bepaalde voordelen ten opzichte van onzuivere functies, waaronder de volgende.

Testbaarheid

Pure functies zijn eenvoudig te testen omdat hun input/output-gedrag goed gedefinieerd is. Ook zijn pure functies niet afhankelijk van externe toestand of bijwerkingen. Daarom kunt u ze afzonderlijk testen zonder u zorgen te hoeven maken over eventuele afhankelijkheden of interacties met andere delen van het programma.

Het testen van onzuivere functies die afhankelijk zijn van de externe toestand of bijwerkingen veroorzaken, kan daarentegen een grotere uitdaging zijn, omdat hun gedrag afhankelijk kan zijn van de toestand van het programma of andere externe factoren. Dit kan het moeilijker maken om uitgebreide testcases te maken en ervoor te zorgen dat de functie zich in alle scenario's correct gedraagt.

Memorisatie

Omdat pure functies altijd dezelfde output produceren voor dezelfde input en geen neveneffecten produceren, kun je ze gemakkelijk onthouden.

Door op deze eigenschappen te vertrouwen en memoisatie te gebruiken, kunt u het resultaat van een zuivere functieaanroep voor een specifieke invoer cachen. Uw functie kan vervolgens het resultaat in de cache retourneren de volgende keer dat het wordt aangeroepen met dezelfde invoer.

Onthouden van pure functies kan de prestaties van een programma verbeteren, vooral voor dure berekeningen die herhaaldelijk met dezelfde invoer te maken hebben, zonder dat u zich zorgen hoeft te maken over interferentie met de status van het programma.

Onzuivere functies kunnen daarentegen verschillende resultaten opleveren voor dezelfde invoer, afhankelijk van de status van het programma of externe factoren. Dit maakt het moeilijk om ze in het geheugen op te slaan, omdat het resultaat in de cache mogelijk niet langer geldig is als de afhankelijkheden van de functie of de externe status tussen aanroepen veranderen.

gelijktijdigheid

Omdat pure functies geen enkele externe status wijzigen of bijwerkingen veroorzaken, zijn ze thread-safe. U kunt ze tegelijkertijd uitvoeren zonder u zorgen te hoeven maken over racecondities of synchronisatieproblemen.

Onzuivere functies daarentegen kunnen een uitdaging zijn om gelijktijdig uit te voeren, omdat ze elkaar kunnen storen of onverwacht gedrag kunnen veroorzaken wanneer ze parallel worden uitgevoerd. Als twee threads bijvoorbeeld toegang hebben tot dezelfde globale variabele en deze wijzigen, kunnen ze elkaars wijzigingen overschrijven of inconsistente resultaten opleveren.

Pure functies vs. Onzuivere functies

U kunt programma's schrijven met een combinatie van pure en onzuivere functies, aangezien elk type zijn eigen gebruik heeft.

Pure-functies zijn eenvoudig te optimaliseren, testen en parallelliseren, waardoor ze geschikt zijn voor use cases zoals functioneel programmeren, caching, testen, parallel programmeren en gegevensverwerkingstaken.

Onzuivere functies vormen echter uitdagingen bij het testen en concurrency, maar zijn nuttig bij het werken met veranderlijke datastructuren of interactie met externe systemen en bronnen.