Funktionel programmering i JavaScript Del 1 - Introduktion

Hvad er funktionel programmering?

"Enkelt sagt er funktionel programmering en softwareudvikling stil, der lægger stor vægt på brugen af funktioner"

Uddrag fra bogen: Luis Atencio "Funktionel programmering i JavaScript. Sådan forbedrer du din JavaScript programmer ved hjælp af funktionelle teknikker"

Funktionel programmering er klassificeret som en deklarativ paradigme, hvor programbeskrivelsen er adskilt fra beregningerne. Her lægges der vægt på brugen af udtryk til at beskrive programlogik. Dette er det modsatte af tvingende nødvendigt programmering, hvor Kode udføres trin for trin og fortæller computeren i detaljer, hvordan den skal udføre opgaven.

Deklarativ vs imperativ, eksempler

Tænk på et tilfælde, hvor vi har en række heltal, og vi er nødt til at opløfte hvert af dem til anden potens og derefter kun vælge de værdier, der ikke er lige.

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 operationer på bits er hurtigere
results.push(secondPower);
}
}

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

Hvad angår tvingende nødvendigt løsning er fokus på implementeringsdetaljer tydeligt. I løkken kan du se array-indekset baseret på behovet for at kontrollere antallet af elementer. På grund af det store antal detaljer i koden er det sværere at fokusere på, hvad den gør. Lad os nu 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 = tal
.map(stigerTilSekundKraft)
.filter(isOdd);

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

I denne løsning er implementeringen blevet adskilt fra påkaldelsen ved at flytte logikken til separate funktioner. Takket være denne løsning kan vi kun fokusere på navnene på de funktioner, der beskriver, hvad der sker i dem. Derudover er abstraktionsniveauet blevet hævet, og logikken kan nu genbruges. Lad os nu fokusere på opkaldet. Du kan ikke se nogen detaljer i det, kun en beskrivelse, der fortæller dig, hvad denne kode gør, trin for trin:

1. map(risesToSecondPower) - tager hvert element i en matrix og hæver det til anden potens,
2. filter(isOdd) - filtrere og vælge ulige elementer.

Fordele

Funktionel programmering har mange fordele. Når det drejer sig om JavaScripter brugen af funktioner naturlig, fordi det er et funktionelt sprog. Selv klasserne i dette sprog er "syntaktisk sukker", og de er underneden sammensat af funktioner.

Når det gælder læsbarhed, bliver koden i den imperative tilgang normalt til en liste med navne på funktioner, der kan læses i rækkefølge uden at dykke ned i deres logik. Derfor fokuserer vi ikke på implementeringsdetaljerne.

En anden fordel er at holde sig til konventionen om uforanderlige objekter. Takket være denne tilgang bliver koden mere sikker, fordi referencerne i JavaScript er meget stærke, og det er nemt at ændre det uønskede objekt.

I funktionel programmering opdeles koden i små funktioner, der let kan betragtes som genanvendelig abstrakt kode.

Ren funktion

En af de vigtige overvejelser i funktionel programmering er rene funktioner. For at skabe en sådan funktion skal du huske et par regler:

• det resultat, som funktionen returnerer, afhænger kun af inputparametrene,
• Brug ikke globale variabler og variabler, der ligger uden for dit eget område,
• ændrer ikke parametrenes tilstand,
• Rene funktioner har ingen "sideeffekter" (som regel ændring af objektets egenskaber),
• for de angivne inputparametre, vil de altid returnere et og samme resultat,
• en ren funktion tager altid en parameter og returnerer altid en parameter.

// Inpure-funktion
lad tæller = 5
...
const multipleCounter = (multiplikator) => {
tæller = tæller * multiplikator
}

multiplyCounter(2) // -> ? resultatet afhænger af den oprindelige værdi

// Ren funktion
const multiplyBy = (multiplikator) => (værdi) => værdi * multiplikator
const multipleByTwo = multiplyBy(2)

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

Den første funktion er uforudsigelig, fordi den afhænger af en ekstern parameter, der kan ændre sig. Den anden funktion er gennemsigtig, den afhænger kun af inputparametre, ændrer dem ikke og bruger ikke variabler uden for området. Den er gennemsigtig, fordi den afhænger af parametre, ikke ændrer dem, ikke bruger variabler uden for området og returnerer en ny værdi.