Funksjonell programmering i JavaScript Del 1 - Introduksjon

Hva er funksjonell programmering?

"Enkelt sagt er funksjonell programmering en programvareutvikling stil som legger stor vekt på bruk av funksjoner"

Utdrag fra boken: Luis Atencio "Funksjonell programmering i JavaScript. Hvordan forbedre din JavaScript programmer ved hjelp av funksjonelle teknikker"

Funksjonell programmering er klassifisert som en deklarativ paradigme der programbeskrivelsen er adskilt fra beregningene. Her legges det vekt på bruk av uttrykk for å beskrive programlogikken. Dette er det motsatte av tvingende nødvendig programmering, hvor kode utføres trinn for trinn og forteller datamaskinen i detalj hvordan jobben skal gjøres.

Deklarativ vs. imperativ, eksempler

Tenk deg et tilfelle der vi har en matrise med heltall, og vi må opphøye hvert av dem til andre potens og deretter bare velge de verdiene som ikke er partall.

Imperativ

const numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9];

const resultater = []

for(let i = 0; i < numbers.length; i++) {
const secondPower = Math.pow(numbers[i], 2)
if(secondPower & 1) { // eller % 2, men operasjoner på bits er raskere
results.push(secondPower);
}
}

console.log(results) // // [1, 9, 25, 49, 81]

Når det gjelder tvingende nødvendig løsningen er fokuset på implementeringsdetaljer tydelig synlig. I løkken kan du se matriseindeksen basert på behovet for å kontrollere antall elementer. På grunn av det store antallet detaljer i koden er det vanskeligere å fokusere på hva den gjør. La oss nå fokusere på deklarativ løsning.

Deklarativ

const risesToSecondPower = (num) => Math.pow(num, 2)
const isOdd = (num) => num & 1;

const numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9]

const resultater = tall
.map(stigerTilSekundKraft)
.filter(isOdd);

console.log(results) // [1, 9, 25, 49, 81]

I denne løsningen er implementeringen skilt fra påkallingen ved at logikken er flyttet til separate funksjoner. Takket være denne løsningen kan vi bare fokusere på navnene på funksjonene som beskriver hva som skjer i dem. I tillegg har abstraksjonsnivået blitt hevet, og logikken kan nå gjenbrukes. La oss nå fokusere på anropet. Du kan ikke se noen detaljer i den, bare en beskrivelse som forteller deg hva denne koden gjør, steg for steg:

1. map(stigerTilSekundKraft) - tar hvert element i en matrise og øker det til andre potens,
2. filter(isOdd) - filter og velg odde elementer.

Fordeler

Funksjonell programmering har mange fordeler. Når det gjelder JavaScripter bruken av funksjoner naturlig fordi det er et funksjonelt språk. Selv klassene i dette språket er "syntaktisk sukker", og de består i bunn og grunn av funksjoner.

Når det gjelder lesbarhet, blir koden i den imperative tilnærmingen vanligvis en liste med navn på funksjoner som kan leses sekvensielt uten å fordype seg i logikken. Derfor fokuserer vi ikke på implementeringsdetaljene.

En annen fordel er at man holder seg til konvensjonen med uforanderlige objekter. Takket være denne tilnærmingen blir koden tryggere fordi referansene i JavaScript er veldig sterke, og det er lett å modifisere det uønskede objektet.

I funksjonell programmering brytes koden ned i små funksjoner som enkelt kan betraktes som gjenbrukbar abstrakt kode.

Ren funksjon

En av de viktigste faktorene i funksjonell programmering er rene funksjoner. For å lage en slik funksjon må du huske noen få regler:

• resultatet som funksjonen returnerer, avhenger bare av inngangsparametrene,
• ikke bruk globale variabler og variabler som ligger utenfor ditt eget område,
• ikke endre tilstanden til parametrene,
• rene funksjoner har ingen "sideeffekter" (vanligvis endring av objektegenskaper),
• for de angitte inngangsparametrene, vil de alltid returnere ett og samme resultat,
• en ren funksjon tar alltid en parameter og returnerer alltid en parameter.

// Inpure-funksjon
let counter = 5
...
const multipleCounter = (multiplikator) => {
teller = teller * multiplikator
}

multiplyCounter(2) // -> ? resultatet avhenger av den opprinnelige verdien

// Ren funksjon
const multiplyBy = (multiplikator) => (verdi) => verdi * multiplikator
const multipleByTwo = multiplyBy(2)

const counter = multiplyByTwo(5) // -> 10

Den første funksjonen er uforutsigbar fordi den er avhengig av en ekstern parameter som kan endre seg. Den andre funksjonen er gjennomsiktig, den avhenger bare av inngangsparametere, endrer dem ikke og bruker ikke variabler utenfor området. Den er gjennomsiktig fordi den er avhengig av parametere, ikke endrer dem, ikke bruker variabler utenfor området og returnerer en ny verdi.