Att arbeta med rena funktioner kan vara mycket mindre stressande, eftersom du enkelt kan testa dem och resonera om dem med större självförtroende.

Rena funktioner är funktioner som inte ger biverkningar och, när de anropas med samma ingångsparametrar, alltid kommer att returnera samma utdata.

Du kan använda rena funktioner för att säkerställa att din kod är ren, underhållsbar och testbar. Dessa funktioner är idealiska för dessa uppgifter eftersom de är förutsägbara och inte ändrar yttre tillstånd.

De är också lättare att felsöka, vilket gör dem till hjälp för att utveckla komplexa programvarusystem. Här kommer du att utforska rena funktioner i JavaScript, deras egenskaper och deras fördelar.

Egenskaper för en ren funktion

För en funktion för att vara "ren" måste den uppfylla några krav.

Konstant returvärde

En ren funktion ska alltid returnera samma värde med samma indata, oavsett hur många gånger den anropas.

Tänk till exempel på funktionen nedan:

fungeramultiplicera(a, b) {
lämna tillbaka a*b;
}
instagram viewer

De multiplicera funktion i exemplet ovan kommer alltid att returnera produkten av sina två argument. Med samma uppsättning argument har den ett konstant returvärde.

Att anropa denna funktion flera gånger med samma argument kommer att ge samma utdata varje gång. Till exempel:

multiplicera(2, 3); // returnerar 6
multiplicera(2, 3); // returnerar 6
multiplicera(2, 3); // returnerar 6

Alternativt kan du överväga exemplet nedan:

fungeramultipliceraRandomNumber(num) {
lämna tillbaka antal * Matematik.golv(Matematik.random() * 10);
}
multipliceraRandomNumber(5); // Oförutsägbara resultat
multipliceraRandomNumber(5); // Oförutsägbara resultat
multipliceraRandomNumber(5); // Oförutsägbara resultat

De multipliceraRandomNumber Funktionen ovan returnerar olika resultat varje gång du anropar den, vilket gör den oren. Resultaten av denna funktion är oförutsägbara, så det är svårt att testa komponenter som förlitar sig på den.

Inga biverkningar

En ren funktion får inte ge några biverkningar. En bieffekt hänvisar till varje modifiering av tillstånd eller beteende utanför funktionens omfattning, såsom modifiering av globala variabler, konsolutdata, nätverksbegäranden eller DOM-manipulation.

När en ren funktion har en bieffekt är den inte längre ren eftersom den påverkar yttre tillstånd och bryter mot principen att inte ha några observerbara biverkningar. Därför undviker rena funktioner biverkningar för att säkerställa att de inte ändrar programmets tillstånd.

Tänk till exempel på exemplet nedan:

låta räkna = 0;
fungeraökning() {
 räkna++;
trösta.log (räkning);
}
ökning(); // Loggar 1
ökning(); // Loggar 2
ökning(); // Loggar 3

De ökning funktionen i det här exemplet har bieffekten att modifiera räkna variabel utanför dess räckvidd. Den loggar också till konsolen.

Denna funktion är inte ren eftersom den har en bieffekt, vilket kan göra det svårare att förutsäga dess utdata och testa isolerat. För att göra den ren kan du modifiera den för att ta in den räkna variabel som ett argument och returnerar det inkrementerade värdet utan att ändra något externt tillstånd.

Såhär:

fungeraökning(räkna) {
lämna tillbaka räkna + 1;
}
ökning(1); // returnerar 2
ökning(1); // returnerar 2
ökning(1); // returnerar 2

Versionen av ökning funktionen i exemplet ovan har inga biverkningar eftersom den inte ändrar någon extern variabel eller loggar något värde. Dessutom, oavsett hur många gånger du anropar det, returnerar det samma värde för samma indata. Därför är det en ren funktion.

Andra egenskaper

Förutom att ha ett konstant avkastningsvärde och inte ge några biverkningar, bör du följa följande regler när du är skapa en JavaScript-funktion att du vill vara ren:

  • Din funktion får inte ändra något av dess argument. Istället, om någon operation kräver mutation, gör en kopia av argumentet och mutera kopian.
  • Din funktion måste alltid ha ett returvärde. Om din funktion inte har ett returvärde eller några biverkningar kan den inte göra någonting!
  • Din funktion får inte bero på något externt tillstånd.

Fördelar med Pure Functions

Rena funktioner har vissa fördelar jämfört med orena funktioner, av vilka några inkluderar följande.

Testbarhet

Rena funktioner är lätta att testa eftersom deras in-/utgångsbeteende är väldefinierat. Dessutom är rena funktioner inte beroende av yttre tillstånd eller biverkningar. Därför kan du testa dem isolerat utan att oroa dig för eventuella beroenden eller interaktioner med andra delar av programmet.

Däremot kan det vara mer utmanande att testa orena funktioner som är beroende av yttre tillstånd eller ger biverkningar eftersom deras beteende kan bero på programmets tillstånd eller andra yttre faktorer. Detta kan göra det svårare att skapa heltäckande testfall och säkerställa att funktionen fungerar korrekt i alla scenarier.

Memoisering

Eftersom rena funktioner alltid producerar samma utdata för samma ingång och inte ger några biverkningar, kan du enkelt memorera dem.

Genom att förlita dig på dessa egenskaper och använda memoisering kan du cachelagra resultatet av ett rent funktionsanrop för en specifik ingång. Din funktion kan sedan returnera det cachade resultatet nästa gång det anropas med samma ingång.

Memoisera rena funktioner kan förbättra ett programs prestanda, särskilt för dyra beräkningar som upprepade gånger hanterar samma indata, utan att oroa sig för störningar i programmets tillstånd.

Däremot kan orena funktioner ge olika resultat för samma ingång, beroende på programmets tillstånd eller externa faktorer. Detta gör dem utmanande att memorera eftersom det cachade resultatet kanske inte längre är giltigt om funktionens beroenden eller externa tillstånd ändras mellan anrop.

Samtidighet

Eftersom rena funktioner inte ändrar något yttre tillstånd eller ger några biverkningar, är de trådsäkra. Du kan köra dem samtidigt utan att oroa dig för tävlingsförhållanden eller synkroniseringsproblem.

Däremot kan orena funktioner vara utmanande att utföra samtidigt eftersom de kan störa varandra eller producera oväntat beteende när de körs parallellt. Till exempel, om två trådar får åtkomst till och modifierar samma globala variabel, kan de skriva över varandras ändringar eller ge inkonsekventa resultat.

Pure Functions vs. Orena funktioner

Du kan skriva program med en kombination av rena och orena funktioner, eftersom varje typ har sina användningsområden.

Rena funktioner är lätta att optimera, testa och parallellisera, vilket gör dem lämpliga för användningsfall som funktionell programmering, cachelagring, testning, parallellprogrammering och databearbetningsuppgifter.

Men orena funktioner utgör utmaningar vid testning och samtidighet men är till hjälp när man arbetar med föränderliga datastrukturer eller interagerar med externa system och resurser.