Functioneel programmeren in JavaScript Deel 1 - Inleiding

Wat is functioneel programmeren?

"Eenvoudig gezegd is functioneel programmeren een softwareontwikkeling stijl die een grote nadruk legt op het gebruik van functies".

Fragmenten uit het boek: Luis Atencio "Functioneel programmeren in JavaScript. Hoe u uw JavaScript programma's met behulp van functionele technieken"

Functioneel programmeren is geclassificeerd als een declaratief paradigma waarbij de programmabeschrijving gescheiden is van de berekeningen. De nadruk ligt hier op het gebruik van expressies om programmalogica te beschrijven. Dit is het tegenovergestelde van dwingend programmering, waarbij de code wordt stap voor stap uitgevoerd en vertelt de computer in detail hoe hij de klus moet klaren.

Declaratief vs imperatief, voorbeelden

Beschouw een geval waarin we een matrix van gehele getallen hebben en we elk daarvan tot de tweede macht moeten verheffen en dan alleen de waarden moeten selecteren die niet even zijn.

Dwingend

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

const resultaten = []

for(let i = 0; i < numbers.length; i++) {
const secondPower = Math.pow(numbers[i], 2)
if(secondPower & 1) { // of % 2 maar bewerkingen op bits zijn sneller
results.push(secondPower);
}
}

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

Wat betreft de dwingend oplossing is de focus op implementatiedetails duidelijk zichtbaar. In de lus kun je de array-index zien op basis van de noodzaak om het aantal elementen te controleren. Door het grote aantal details in de code is het moeilijker om te focussen op wat het doet. Laten we ons nu richten op de declaratief oplossing.

Declaratief

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

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

const resultaten = getallen
.map(risesToSecondPower)
.filter(isOdd);

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

In deze oplossing is het implementeren gescheiden van het aanroepen door de logica naar aparte functies te brengen. Dankzij deze oplossing kunnen we ons alleen richten op de namen van functies die beschrijven wat er in de functies gebeurt. Bovendien is het abstractieniveau verhoogd en kan de logica nu herbruikbaar zijn. Laten we ons nu richten op de aanroep. Je ziet er geen details in, alleen een beschrijving die je stap voor stap vertelt wat deze code doet:

1. map(risesToSecondPower) - neemt elk element van een matrix en verheft het tot de tweede macht,
2. filter(isOdd) - filter en selecteer oneven elementen.

Voordelen

Functioneel programmeren heeft veel voordelen. Als het gaat om JavaScriptHet gebruik van functies is natuurlijk omdat het een functionele taal is. Zelfs de klassen in deze taal zijn "syntactische suiker" en ze zijn onderliggend samengesteld uit functies.

Als het op leesbaarheid aankomt, wordt de code in de imperatieve aanpak meestal een lijst met namen van functies die opeenvolgend kunnen worden gelezen zonder in hun logica te duiken. Als gevolg daarvan richten we ons niet op de implementatiedetails.

Een ander voordeel is het vasthouden aan de conventie van onveranderlijke objecten. Dankzij deze aanpak wordt de code veiliger omdat de verwijzingen in JavaScript zijn erg sterk en het is gemakkelijk om het ongewenste object aan te passen.

Bij functioneel programmeren wordt de code opgesplitst in kleine functies die gemakkelijk kunnen worden gezien als herbruikbare abstracte code.

Zuivere functie

Een van de belangrijke overwegingen bij functioneel programmeren zijn pure functies. Om zo'n functie te maken, moet je een paar regels onthouden:

• het resultaat dat de functie retourneert hangt alleen af van de invoerparameters,
• gebruik geen globale variabelen en variabelen die buiten je eigen bereik liggen,
• veranderen de status van de parameters niet,
• Zuivere functies hebben geen "neveneffecten" (meestal het wijzigen van objecteigenschappen),
• voor de aangegeven invoerparameters, zullen ze altijd één en hetzelfde resultaat teruggeven,
• Een pure functie neemt altijd een parameter en geeft altijd een parameter terug.

// Inpureerfunctie
laat teller = 5
...
const multipleCounter = (vermenigvuldiger) => {
teller = teller * vermenigvuldiger
}

multiplyCounter(2) // -> ? het resultaat hangt af van de beginwaarde

// Zuivere functie
const multiplyBy = (vermenigvuldiger) => (waarde) => waarde * vermenigvuldiger
const multipleByTwo = multiplyBy(2)

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

De eerste functie is onvoorspelbaar omdat deze afhankelijk is van een externe parameter die kan veranderen. De tweede functie is transparant, deze is alleen afhankelijk van invoerparameters, wijzigt deze niet en gebruikt geen variabelen buiten het bereik. Het is transparant omdat het afhankelijk is van parameters, deze niet wijzigt, geen variabelen buiten het bereik gebruikt en een nieuwe waarde retourneert.