Funktionell programmering i JavaScript Del 1 - Introduktion

Vad är funktionell programmering?

"Enkelt uttryckt är funktionell programmering en Utveckling av programvara stil som lägger stor vikt vid användningen av funktioner"

Utdrag ur boken: Luis Atencio "Funktionell programmering i JavaScript. Hur du kan förbättra din JavaScript program som använder funktionella tekniker"

Funktionell programmering är klassificerad som en deklarativ paradigm där programbeskrivningen är separerad från beräkningarna. Tyngdpunkten ligger här på att använda uttryck för att beskriva programlogiken. Detta är motsatsen till tvingande programmering, där kod utförs steg för steg och talar om för datorn i detalj hur jobbet ska utföras.

Deklarativ vs imperativ, exempel

Tänk på ett fall där vi har en matris med heltal och vi måste höja vart och ett av dem till andra potensen och sedan bara välja de värden som inte är jämna.

Imperativ

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

const resultat = []

for(let i = 0; i < numbers.length; i++) {
const secondPower = Math.pow(siffror[i], 2)
if(secondPower & 1) { // eller % 2 men operationer på bitar är snabbare
resultat.push(andraPower);
}
}

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

När det gäller tvingande lösningen är fokus på implementeringsdetaljer tydligt synligt. I loopen kan du se arrayindexet baserat på behovet av att kontrollera antalet element. På grund av det stora antalet detaljer i koden är det svårare att fokusera på vad den gör. Låt oss nu fokusera 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 resultat = siffror
.map(stigerTillSekundmakt)
.filter(isOdd);

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

I den här lösningen har implementeringen separerats från anropet genom att logiken har flyttats till separata funktioner. Tack vare den här lösningen kan vi bara fokusera på namnen på funktionerna som beskriver vad som händer i dem. Dessutom har abstraktionsnivån höjts och logiken kan nu återanvändas. Låt oss nu fokusera på samtalet. Du kan inte se några detaljer i den, bara en beskrivning som berättar vad den här koden gör, steg för steg:

1. map(stigerTillSekundmakt) - tar varje element i en array och höjer det till andra potensen,
2. filter(isOdd) - filtrera och välja udda element.

Fördelar

Funktionell programmering har många fördelar. När det gäller JavaScriptär användningen av funktioner naturlig eftersom det är ett funktionellt språk. Till och med klasserna i detta språk är "syntaktiskt socker" och de består underifrån av funktioner.

När det gäller läsbarhet blir koden i den imperativa metoden vanligtvis en lista med namn på funktioner som kan läsas sekventiellt utan att fördjupa sig i deras logik. Som ett resultat fokuserar vi inte på implementeringsdetaljerna.

En annan fördel är att hålla sig till konventionen med oföränderliga objekt. Tack vare detta tillvägagångssätt blir koden säkrare eftersom referenserna i JavaScript är mycket starka och det är lätt att modifiera det oönskade objektet.

I funktionell programmering bryts koden ner i små funktioner som enkelt kan betraktas som återanvändbar abstrakt kod.

Ren funktion

En av de viktigaste aspekterna inom funktionell programmering är rena funktioner. För att skapa en sådan funktion måste du komma ihåg några regler:

• det resultat som funktionen returnerar beror endast på inmatningsparametrarna,
• använd inte globala variabler och variabler som ligger utanför ditt eget område,
• ändrar inte parametrarnas tillstånd,
• rena funktioner har inga "sidoeffekter" (vanligtvis modifiering av objektets egenskaper),
• för de angivna indataparametrarna kommer de alltid att ge ett och samma resultat,
• en ren funktion tar alltid en parameter och returnerar alltid en parameter.

// Funktion för inmatning
låt räknare = 5
...
const multipleCounter = (multiplikator) => {
räknare = räknare * multiplikator
}

multiplyCounter(2) // -> ? resultatet beror på det ursprungliga värdet

// Ren funktion
const multiplyBy = (multiplikator) => (värde) => värde * multiplikator
const multipleByTwo = multiplyBy(2)

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

Den första funktionen är oförutsägbar eftersom den är beroende av en extern parameter som kan ändras. Den andra funktionen är transparent, den beror bara på inparametrar, ändrar dem inte och använder inte variabler utanför intervallet. Den är transparent eftersom den är beroende av parametrar, inte ändrar dem, inte använder variabler utanför intervallet och returnerar ett nytt värde.