Rene funksjoner i JavaScript og hvordan du lager dem

Rene funksjoner er funksjoner som ikke gir bivirkninger, og når de kalles med de samme inngangsparametrene, vil de alltid returnere samme utgang.

Du kan bruke rene funksjoner for å sikre at koden din er ren, vedlikeholdbar og testbar. Disse funksjonene er ideelle for disse oppgavene fordi de er forutsigbare og ikke endrer eksterne tilstander.

De er også lettere å feilsøke, noe som gjør dem nyttige i å utvikle komplekse programvaresystemer. Her vil du utforske rene funksjoner i JavaScript, deres egenskaper og deres fordeler.

Kjennetegn på en ren funksjon

Til en funksjon for å være "ren", må den tilfredsstille noen få krav.

Konstant returverdi

En ren funksjon skal alltid returnere samme verdi gitt samme input, uavhengig av antall ganger den kalles.

Tenk for eksempel på funksjonen nedenfor:

funksjonmultiplisere(a, b) {
komme tilbake a * b;
}

De multiplisere funksjonen i eksemplet ovenfor vil alltid returnere produktet av de to argumentene. Gitt det samme settet med argumenter, har det en konstant returverdi.

Å kalle denne funksjonen flere ganger med de samme argumentene vil gi samme utgang hver gang. For eksempel:

multiplisere(2, 3); // returnerer 6
multiplisere(2, 3); // returnerer 6
multiplisere(2, 3); // returnerer 6

Alternativt kan du vurdere eksempelet nedenfor:

funksjonmultiplisereTilfeldigTall(num) {
komme tilbake antall * Matte.gulv(Matte.random() * 10);
}
multiplisereTilfeldigTall(5); // Uforutsigbare resultater
multiplisereTilfeldigTall(5); // Uforutsigbare resultater
multiplisereTilfeldigTall(5); // Uforutsigbare resultater

De multiplisereTilfeldigTall funksjonen ovenfor vil returnere forskjellige resultater hver gang du kaller den, noe som gjør den uren. Resultatene av denne funksjonen er uforutsigbare, så det er vanskelig å teste komponenter som er avhengige av den.

Ingen bivirkninger

En ren funksjon må ikke gi noen bivirkninger. En bieffekt refererer til enhver endring av tilstand eller atferd utenfor funksjonens omfang, for eksempel modifisering av globale variabler, konsollutdata, nettverksforespørsler eller DOM-manipulasjon.

Når en ren funksjon har en bivirkning, er den ikke lenger ren fordi den påvirker ytre tilstand og bryter med prinsippet om å ikke ha noen observerbare bivirkninger. Derfor unngår rene funksjoner bivirkninger for å sikre at de ikke endrer programmets tilstand.

Tenk for eksempel på eksemplet nedenfor:

la telle = 0;
funksjonøke() {
 telle++;
konsoll.log (telling);
}
inkrement(); // Logger 1
inkrement(); // Logger 2
inkrement(); // Logger 3

De øke funksjonen i dette eksemplet har bivirkningen av å modifisere telle variabel utenfor omfanget. Den logger også på konsollen.

Denne funksjonen er ikke ren fordi den har en bivirkning, som kan gjøre det vanskeligere å forutsi produksjonen og teste den isolert. For å gjøre det rent, kan du endre det for å ta inn telle variabel som et argument og returnerer den økte verdien uten å endre noen ekstern tilstand.

Som så:

funksjonøke(telle) {
komme tilbake telle + 1;
}
øke(1); // returnerer 2
øke(1); // returnerer 2
øke(1); // returnerer 2

Versjonen av øke funksjonen i eksemplet ovenfor har ingen bivirkninger siden den ikke endrer noen ekstern variabel eller logger noen verdi. I tillegg, uansett hvor mange ganger du ringer det, returnerer det samme verdi for samme inngang. Derfor er det en ren funksjon.

Andre kjennetegn

I tillegg til å ha en konstant returverdi og ikke gi noen bivirkninger, bør du følge følgende regler når du er opprette en JavaScript-funksjon at du vil være ren:

• Funksjonen din må ikke endre noen av argumentene. I stedet, hvis en operasjon krever mutasjon, lag en kopi av argumentet og muter kopien.
• Din funksjon må alltid ha en returverdi. Hvis funksjonen din ikke har en returverdi eller noen bivirkninger, kan den ikke gjøre noe!
• Din funksjon må ikke avhenge av noen ekstern tilstand.

Fordeler med Pure Functions

Rene funksjoner har visse fordeler fremfor urene funksjoner, hvorav noen inkluderer følgende.

Testbarhet

Rene funksjoner er enkle å teste ettersom deres input/output-atferd er veldefinert. Rene funksjoner er heller ikke avhengig av ytre tilstand eller bivirkninger. Derfor kan du teste dem isolert uten å bekymre deg for avhengigheter eller interaksjoner med andre deler av programmet.

I motsetning til dette kan det være mer utfordrende å teste urene funksjoner som er avhengige av ekstern tilstand eller gir bivirkninger, fordi oppførselen deres kan avhenge av programmets tilstand eller andre eksterne faktorer. Dette kan gjøre det vanskeligere å lage omfattende testcases og sikre at funksjonen oppfører seg riktig i alle scenarier.

Memoisering

Fordi rene funksjoner alltid produserer samme utgang for samme inngang og gir ingen bivirkninger, kan du enkelt huske dem.

Ved å stole på disse egenskapene og bruke memoisering, kan du cache resultatet av et rent funksjonskall for en spesifikk inngang. Funksjonen din kan deretter returnere det bufrede resultatet neste gang det kalles opp med samme inngang.

Lagre rene funksjoner kan forbedre ytelsen til et program, spesielt for dyre beregninger som gjentatte ganger håndterer den samme inngangen, uten å bekymre deg for forstyrrelse av programmets tilstand.

I motsetning til dette kan urene funksjoner gi forskjellige resultater for samme inngang, avhengig av programmets tilstand eller eksterne faktorer. Dette gjør dem utfordrende å huske fordi det hurtigbufrede resultatet kanskje ikke lenger er gyldig hvis funksjonens avhengigheter eller eksterne tilstand endres mellom anrop.

Samtidighet

Siden rene funksjoner ikke endrer noen ytre tilstand eller gir noen bivirkninger, er de trådsikre. Du kan kjøre dem samtidig uten å bekymre deg for løpsforhold eller synkroniseringsproblemer.

I motsetning til dette kan urene funksjoner være utfordrende å utføre samtidig fordi de kan forstyrre hverandre eller produsere uventet oppførsel når de utføres parallelt. For eksempel, hvis to tråder får tilgang til og endrer den samme globale variabelen, kan de overskrive hverandres endringer eller gi inkonsistente resultater.

Rene funksjoner vs. Urene funksjoner

Du kan skrive programmer ved å bruke en kombinasjon av rene og urene funksjoner, siden hver type har sine bruksområder.

Rene funksjoner er enkle å optimalisere, teste og parallellisere, noe som gjør dem egnet for brukstilfeller som funksjonell programmering, caching, testing, parallell programmering og databehandlingsoppgaver.

Imidlertid utgjør urene funksjoner utfordringer i testing og samtidighet, men er nyttige når du arbeider med foranderlige datastrukturer eller samhandler med eksterne systemer og ressurser.