Rene funktioner i JavaScript og hvordan man opretter dem

Rene funktioner er funktioner, der ikke giver bivirkninger, og når de kaldes med de samme inputparametre, vil de altid returnere det samme output.

Du kan bruge rene funktioner til at sikre, at din kode er ren, vedligeholdelig og testbar. Disse funktioner er ideelle til disse opgaver, fordi de er forudsigelige og ikke ændrer eksterne tilstande.

De er også nemmere at fejlfinde, hvilket gør dem nyttige til at udvikle komplekse softwaresystemer. Her vil du udforske rene funktioner i JavaScript, deres egenskaber og deres fordele.

Karakteristika for en ren funktion

Til en funktion for at være "ren", skal den opfylde nogle få krav.

Konstant returværdi

En ren funktion skal altid returnere den samme værdi givet det samme input, uanset hvor mange gange den kaldes.

Overvej for eksempel funktionen nedenfor:

fungereformere sig(a, b) {
Vend tilbage a * b;
}

Det formere sig funktion i eksemplet ovenfor vil altid returnere produktet af sine to argumenter. Givet det samme sæt af argumenter, har det en konstant returværdi.

At kalde denne funktion flere gange med de samme argumenter vil give det samme output hver gang. For eksempel:

formere sig(2, 3); // returnerer 6
formere sig(2, 3); // returnerer 6
formere sig(2, 3); // returnerer 6

Alternativt kan du overveje eksemplet nedenfor:

fungeremultiplicerRandomNumber(num) {
Vend tilbage antal * Matematik.etage(Matematik.random() * 10);
}
multiplicerRandomNumber(5); // Uforudsigelige resultater
multiplicerRandomNumber(5); // Uforudsigelige resultater
multiplicerRandomNumber(5); // Uforudsigelige resultater

Det multiplicerRandomNumber Funktionen ovenfor vil returnere forskellige resultater, hver gang du kalder den, hvilket gør den uren. Resultaterne af denne funktion er uforudsigelige, så det er svært at teste komponenter, der er afhængige af den.

Ingen bivirkninger

En ren funktion må ikke give bivirkninger. En bivirkning refererer til enhver ændring af tilstand eller adfærd uden for funktionens omfang, såsom ændring af globale variabler, konsoloutput, netværksanmodninger eller DOM-manipulation.

Når en ren funktion har en bivirkning, er den ikke længere ren, fordi den påvirker ydre tilstand og overtræder princippet om ikke at have nogen observerbare bivirkninger. Derfor undgår rene funktioner bivirkninger for at sikre, at de ikke ændrer programmets tilstand.

Overvej for eksempel eksemplet nedenfor:

lade tælle = 0;
fungerestigning() {
 tælle++;
konsol.log (tælle);
}
stigning(); // Logs 1
stigning(); // Logs 2
stigning(); // Logs 3

Det stigning funktionen i dette eksempel har den bivirkning, at den ændrer tælle variabel uden for dens anvendelsesområde. Den logger også på konsollen.

Denne funktion er ikke ren, fordi den har en bivirkning, som kan gøre det sværere at forudsige dens output og teste isoleret. For at gøre det rent, kan du ændre det til at tage i tælle variabel som et argument og returnerer den øgede værdi uden at ændre nogen ekstern tilstand.

Ligesom:

fungerestigning(tælle) {
Vend tilbage tælle + 1;
}
stigning(1); // returnerer 2
stigning(1); // returnerer 2
stigning(1); // returnerer 2

Udgaven af stigning Funktionen i eksemplet ovenfor har ingen bivirkninger, da den ikke ændrer nogen ekstern variabel eller logger nogen værdi. Derudover, uanset hvor mange gange du kalder det, returnerer det den samme værdi for det samme input. Derfor er det en ren funktion.

Andre egenskaber

Ud over at have en konstant returværdi og ikke give bivirkninger, bør du overholde følgende regler, når du er oprettelse af en JavaScript-funktion at du vil være ren:

• Din funktion må ikke ændre nogen af ​​dens argumenter. I stedet, hvis en handling kræver mutation, skal du lave en kopi af argumentet og mutere kopien.
• Din funktion skal altid have en returværdi. Hvis din funktion ikke har en returværdi eller nogen bivirkninger, kan den ikke gøre noget!
• Din funktion må ikke afhænge af nogen ekstern tilstand.

Fordele ved Pure Functions

Rene funktioner har visse fordele i forhold til urene funktioner, hvoraf nogle inkluderer følgende.

Testbarhed

Rene funktioner er nemme at teste, da deres input/output adfærd er veldefineret. Rene funktioner afhænger heller ikke af ydre tilstand eller bivirkninger. Derfor kan du teste dem isoleret uden at bekymre dig om afhængigheder eller interaktioner med andre dele af programmet.

I modsætning hertil kan det være mere udfordrende at teste urene funktioner, der afhænger af ydre tilstand eller giver bivirkninger, fordi deres adfærd kan afhænge af programmets tilstand eller andre eksterne faktorer. Dette kan gøre det sværere at skabe omfattende testcases og sikre, at funktionen opfører sig korrekt i alle scenarier.

Memoisering

Fordi rene funktioner altid producerer det samme output for det samme input og giver ingen bivirkninger, kan du nemt huske dem.

Ved at stole på disse egenskaber og bruge memoization, kan du cache resultatet af et rent funktionskald for et specifikt input. Din funktion kan derefter returnere det cachelagrede resultat, næste gang det kaldes med samme input.

Memoisering af rene funktioner kan forbedre et programs ydeevne, især for dyre beregninger, der gentagne gange behandler det samme input, uden at bekymre dig om interferens med programmets tilstand.

I modsætning hertil kan urene funktioner producere forskellige resultater for det samme input, afhængigt af programmets tilstand eller eksterne faktorer. Dette gør dem udfordrende at huske, fordi det cachelagrede resultat muligvis ikke længere er gyldigt, hvis funktionens afhængigheder eller eksterne tilstand ændres mellem opkald.

Samtidighed

Da rene funktioner ikke ændrer nogen ekstern tilstand eller giver bivirkninger, er de trådsikre. Du kan køre dem samtidigt uden at bekymre dig om løbsforhold eller synkroniseringsproblemer.

I modsætning hertil kan urene funktioner være udfordrende at udføre samtidigt, fordi de kan forstyrre hinanden eller producere uventet adfærd, når de udføres parallelt. For eksempel, hvis to tråde får adgang til og ændrer den samme globale variabel, kan de overskrive hinandens ændringer eller producere inkonsistente resultater.

Rene funktioner vs. Urene funktioner

Du kan skrive programmer ved at bruge en kombination af rene og urene funktioner, da hver type har sine anvendelser.

Rene funktioner er nemme at optimere, teste og parallelisere, hvilket gør dem velegnede til brugstilfælde såsom funktionel programmering, caching, test, parallel programmering og databehandlingsopgaver.

Imidlertid udgør urene funktioner udfordringer i test og samtidighed, men de er nyttige, når du arbejder med foranderlige datastrukturer eller interagerer med eksterne systemer og ressourcer.