Functioneel programmeren in JavaScript helpt je code eenvoudiger, leesbaarder en onderhoudbaarder te maken door het gebruik van zuivere functies, immutabiliteit en hogere-orde functies. Hieronder leg ik deze concepten uit en geef ik voorbeelden, inclusief een verbetering van je bestaande functie. 1. Zuivere functies (Pure functions) Een zuivere functie geeft altijd hetzelfde resultaat voor dezelfde invoer en heeft geen bijwerkingen. Voorbeeld: ```javascript function multiply(a, b) { return a * b; } ``` Deze functie is al zuiver omdat het altijd hetzelfde resultaat geeft voor dezelfde `a` en `b`, en geen externe staat beïnvloedt. 2. Immutabiliteit Immutabiliteit betekent dat je data niet wijzigt nadat het is aangemaakt. In JavaScript kun je bijvoorbeeld geen objecten of arrays aanpassen, maar nieuwe maken. Voor je eenvoudige `multiply`-functie is dat niet relevant, maar stel dat je een array van getallen hebt en deze wilt vermenigvuldigen zonder de originele array te veranderen. 3. Hogere-orde functies (Higher-order functions) Dit zijn functies die andere functies als argumenten nemen of teruggeven. Ze maken je code krachtiger en herbruikbaarder. Voorbeeld: Stel dat je meerdere getallen wilt vermenigvuldigen, kun je een hogere-orde functie maken: ```javascript const multiplyAll = (numbers, multiplier) => { return numbers.map(number => multiply(number, multiplier)); }; ``` **Verbeterd voorbeeld met jouw multiply-functie:** ```javascript // Zuivere functie const multiply = (a, b) => a * b; // Hogere-orde functie die alle elementen in een array vermenigvuldigt met een factor const multiplyArray = (arr, factor) => arr.map(number => multiply(number, factor)); // Gebruik const getallen = [1, 2, 3, 4]; const resultaat = multiplyArray(getallen, 10); // [10, 20, 30, 40] ``` **Samenvatting:** - Maak functies zuiver door geen externe staat te beïnvloeden. - Gebruik onveranderlijke data door bijvoorbeeld `.map()`, `.filter()` en `.reduce()`. - Gebruik hogere-orde functies om generaliseerbare en herbruikbare code te schrijven. Door deze principes toe te passen, wordt je JavaScript-code eenvoudiger, voorspelbaarder en gemakkelijker te onderhouden.

Functioneel programmeren in JavaScript draait om drie kernprincipes die je code eenvoudiger en onderhoudbaarder maken: ## 1. Pure Functies Je voorbeeld is al een pure functie - perfect! ```javascript function multiply(a, b) { return a * b; } // Altijd hetzelfde resultaat voor dezelfde input // Geen neveneffecten (geen verandering van externe state) ``` ## 2. Immutabiliteit (Onveranderlijkheid) ```javascript // Slechte praktijk - mutatie const numbers = [1, 2, 3]; numbers.push(4); // ❌ Verandert de originele array // Goede praktijk - immutabiliteit const originalNumbers = [1, 2, 3]; const newNumbers = [...originalNumbers, 4]; // ✅ Creëert nieuwe array ``` ## 3. Hogere-orde Functies ```javascript // Map - transformeert elk element const numbers = [1, 2, 3]; const doubled = numbers.map(n => multiply(n, 2)); // [2, 4, 6] // Filter - selecteert elementen const evenNumbers = numbers.filter(n => n % 2 === 0); // [2] // Reduce - combineert elementen const sum = numbers.reduce((acc, n) => acc + n, 0); // 6 ``` ## Praktisch voorbeeld: ```javascript // Functionele aanpak voor dataverwerking const products = [ { name: 'Laptop', price: 1000, quantity: 2 }, { name: 'Mouse', price: 25, quantity: 5 } ]; // Pure functies const calculateTotal = (price, quantity) => multiply(price, quantity); const addTax = (amount, taxRate = 0.21) => multiply(amount, 1 + taxRate); // Dataverwerking met hogere-orde functies const totals = products.map(product => calculateTotal(product.price, product.quantity) ); const totalsWithTax = totals.map(total => addTax(total)); console.log(totalsWithTax); // [2420, 151.25] ``` **Voordelen:** Betere testbaarheid, voorspelbaardere code, eenvoudigere debugging en betere onderhoudbaarheid door minder side effects.