Oct 25, 2017 · 7 min read

Functional programming is a highly valued approach to writing code, and it’s popularity is continuously increasing in commerciële softwaretoepassingen. Functioneel programmeren is een paradigma van het schrijven van code en wordt welsprekend gezet in de introductie van dit Wikipedia artikel:

” -een stijl van het bouwen van de structuur en elementen van computerprogramma ‘ s — die computatie behandelt als de evaluatie van wiskundige functies en vermijdt het veranderen-toestand en veranderlijke gegevens. Het is een declaratief programmeerparadigma, wat betekent dat programmeren wordt gedaan met uitdrukkingen of verklaringen in plaats van verklaringen.”

We zullen heel snel ingaan op wat dit precies betekent, maar laten we eerst de grondbeginselen uit de weg ruimen door wat context te geven. Dit artikel dient het doel van hopelijk de invoering van de fundamentele concepten van functioneel programmeren aan u en tegen het einde van het, we zouden hebben vastgesteld een basis begrip van waarom we zouden kiezen om het toe te passen in onze codering stijlen, hoe het betrekking heeft op JavaScript en een aantal fundamentele patronen die u kunt beginnen met de uitvoering in uw code. Wees op de uitkijk voor een tweede artikel dat zal voortbouwen op deze en graven nog dieper in de ideeën hier besproken.

de wortels van functioneel programmeren liggen in Lambda calculus, een systeem ontwikkeld in de jaren 1930 om berekeningen uit te drukken met functies die vergelijkbaar zijn met wat we zeer binnenkort zullen zien. Al geruime tijd werden functionele programmeerconcepten en-talen in de academische wereld en wetenschappelijke contexten op grote schaal besproken en uiteindelijk gebloed in de ontwikkeling van commerciële software. Wat maakt een programmeertaal functioneel of niet is de mogelijkheid om de functionele programmering paradigma te vergemakkelijken, talen zoals deze zijn Ruby, Python, Julia en JavaScript, de laatste van die eigenschappen van imperatieve, object-georiënteerde en functionele paradigma ‘ s heeft.

laten we eens kijken naar een voorbeeld van het gebruik van een imperatief, en dan een functionele benadering van het voltooien van een enkele taak.

imperatief:

const arr = function getOdds(arr){
let odds = ; for(let i = 0; i < arr.length + 1; i++){
if ( i % 2 !== 0 ){
odds.push( i )
};
};
return odds
};console.log(getOdds(arr))
// logs 

functioneel:

function getOdds2(arr){
return arr.filter(num => num % 2 !== 0)
}console.log(getOdds2(arr))
// logs // this can be even shorter
const getOdds3 = arr => arr.filter(num => num % 2 !== 0)console.log(getOdds3(arr))
// logs 

afgezien van de voor de hand liggende verbeteringen die de functionele aanpak maakt, zoals kortere code, bespaart ons een paar toetsaanslagen, en het feit dat het veel gemakkelijker te begrijpen in een snelle blik, het is ook elegant, wat resulteert in schonere code, vereenvoudigt debuggen, testen en onderhoud.

laten we dit een beetje opsplitsen, zodat we een duidelijk begrip kunnen krijgen van de verschillen tussen de twee benaderingen en definiëren wat functioneel programmeren is.

in de eerste benadering beschrijven we elke gebeurtenis die moet plaatsvinden om de taak te bereiken om de oneven getallen uit een array te filteren. We voeden een functie een array, binnen de functie maken we een lege array die we zullen gebruiken om de oneven getallen in op te slaan. We vertellen het om te lus over de array, dan verklaren we een voorwaardelijke, als de huidige index is een oneven getal, duw het naar de lege. De for-lus bevat niet het laatste nummer in de array, het bevat alleen de nummers voorafgaand aan het, dus als ons laatste nummer oneven is, zal het niet worden opgenomen. Daarom voegen we +1 toe bij het bepalen van de hoeveelheid herhalingen die onze lus moet maken.

in de tweede benadering definiëren we eenvoudig het resultaat dat we willen zien met behulp van een methode genaamd filter, en laten we de machine toe om alle stappen daartussen te nemen. Dit is een meer declaratieve benadering. Wij verklaren wat het eindresultaat moet zijn, en wij de rest wordt voor ons afgehandeld.

nu kunnen we zien wat de bovenstaande definitie probeert uit te drukken. Een manier van programmeren, met behulp van verklaringen en uitdrukkingen, in plaats van verklaringen. Deze definitie schraapt alleen het oppervlak van functionele programmering, en we zullen voortdurend voortbouwen op onze definitie als ons begrip groeit.

enkele verschillen tussen iteratieve en functionele benaderingen.

• stilistisch definiëren we een probleem en de veranderingen die we zouden willen zien, in tegenstelling tot het stap voor stap uitleggen.
• We hoeven de status niet te beheren in onze functies zoals hierboven waar we de status van onze lege array hebben beheerd.
• we hoeven ons minder zorgen te maken over de volgorde van uitvoering.
• we gebruiken minder lussen, condities en meer ingebouwde methoden, herbruikbare functies en recursie.

door deze aanpak te gebruiken, schrijven we uiteindelijk cleaner code die ons, zoals hierboven vermeld, helpt bij het debuggen en onderhoud. Het houdt dingen modulair, en delen van onze code is opgesplitst in kleinere stukken die we kunnen testen met gemak. We kunnen delen van onze code hergebruiken met behulp van helperfuncties en tot slot is het een efficiëntere, wiskundige benadering om code te schrijven.

de pijlers: Onze codering toolkit voor het schrijven van functionele code

de volgende zijn een paar belangrijke aspecten voor het schrijven van functionele code van hoge kwaliteit. Aangezien dit een overzicht is, zullen we niet te veel in elk duiken, in plaats daarvan zullen we slechts een paar belangrijke kenmerken en een voorbeeld van elk definiëren.

Pure functies:

Pure functies retourneren een waarde uitsluitend gebaseerd op wat erin werd doorgegeven. Het idee erachter is dat het een zuivere functie zal zijn als het altijd hetzelfde resultaat geeft als dezelfde waarden erin worden doorgegeven, en het wijzigt geen waarden buiten het TS-bereik, dat maakt het onafhankelijk van elke staat in het systeem. Daarom kan een zuivere functie nooit gegevens muteren, geen bijwerkingen veroorzaken en gemakkelijk worden hergebruikt. Een voorbeeld van een niet-zuivere functie zal een functie zijn die een API call maakt of een onvoorspelbaar resultaat retourneert.

eenvoudige onzuivere functie:

var tip = 0;function calculateTip( mealTotal ) {
tip = 0.15 * mealTotal;
}calculateTip( 150 )
console.log(tip)

eenvoudige zuivere functie:

function isPure(x,y) {
return x * y
}console.log(isPure(3,5));

de pure functie geeft elke keer het exacte resultaat terug, en het muteert geen gegevens daarbuiten. Het belangrijkste om op te letten is dat een pure functie uit de buurt moet blijven van het muteren van gegevens, dus wees voorzichtig bij het selecteren van welke methoden te gebruiken binnen uw pure functies. Bijvoorbeeld, als je twee arrays in je functie wilt samenvoegen, zoals een normaal zou doen in een React reducer, vermijd dan het gebruik van de Array.prototype.push () methode. In plaats daarvan zou je Array willen gebruiken.prototype.concat (), die de staat van de oude arrays zal behouden en een nieuwe zal teruggeven voor jouw gebruik.

hogere orde functies:

in Javascript worden functies behandeld als objecten, daarom kunnen we functies doorgeven zoals elke andere waarde. Een hogere orde functie is gewoon een functie die werkt op andere functies. Ze kunnen een functie opnemen als input, of een functie retourneren als output. We zullen een eenvoudig voorbeeld zien in de volgende demonstratie.

anonieme functies:

anonieme functies zijn zeer nuttig wanneer we ad-hoclogica moeten definiëren zoals we nodig hebben. Zoals de naam al aangeeft, een anonieme functie in naamloos, en meestal gevonden Als een argument voor een functie als vervanging voor een benoemde functie, een functie toegewezen aan een variabele, of geretourneerd als een functie in een hogere orde functie. Zijn wortels liggen zwaar in Lambda calculus en is zeer belangrijk voor alle functionele programmeertalen.

anonieme functie toegewezen aan een variabele. Gemakkelijk door te geven en te roepen wanneer dat nodig is.

const myVar = function(){console.log(‘Anonymous function here!’)}myVar()

anonieme functie als argument

setInterval(function(){console.log(new Date().getTime())}, 1000);

anonieme functies binnen een hogere orde functie

function mealCall(meal){
return function(message){
return console.log(message + " " + meal + ‘!!’)
}
}const announceDinner = mealCall(‘dinner’)
const announceLunch = mealCall(‘breakfast’)announceDinner(‘hey!, come and get your’)
announceLunch(‘Rise and shine! time for’)

recursie is een bekende functionele programmeertechniek. Een recursieve functie is gewoon een functie die zichzelf aanroept en daarom fungeert als een loop die dezelfde code meerdere keren uitvoert. Het komt met een voorbehoud echter, men moet voorzichtig zijn om oneindige recursies te voorkomen. Daarom is een basisgeval nodig, om het te vertellen wanneer te stoppen. Recursieve functies of algoritmen kunnen beide worden geïmplementeerd met behulp van recursie en loops, maar het is beter om recursie te gebruiken. Hieronder is het bekende algoritme voor het factoriseren van een getal zowel met behulp van recursie en een lus.

recursieve functie

function factorialize(num){
if (num === 0 || num === 1){return 1;}
return (num * factorialize(num — 1));
}var result = factorialize(14);console.log(result);

recursie met behulp van een lus

function factorialize(num) {
if (num === 0 || num === 1){
return 1;
}
for (var i = num-1; i >= 1; i-- ) {
num *= i;
}
return num;
}
console.log(factorialize(6));

we hebben enkele essentiële ingrediënten behandeld om functionele code te schrijven. Het is niet mogelijk om altijd functionele code te schrijven in een toepassing, maar de voordelen zijn groot wanneer zoveel mogelijk gebruikt. Frameworks zoals Angular en React zijn sterk beïnvloed door functionele programmering, en bibliotheken zoals Redux en Lodash stellen ons in staat om de voordelen ervan te gebruiken, dus er is zeker een groot voordeel om te beginnen denken in de FP manier.

bronnen om meer te leren? Hier zijn een aantal grote artikelen en middelen voor verder leren.

• waarom functioneel programmeren in JavaScript leren? door Eric Elliot
• Welsprekende JavaScript door Marijn Haverbeke
• Dus je wilt een Functionele Programmeur van Charles Scalfani

ik hoop echt dat dit nuttig was en in het volgende artikel gaan we duiken een beetje dieper en pak nog meer interessante en nuttige tools, zoals een JavaScript-methoden, gedeeltelijke toepassing, currying, argument bindend en meer.

voel je vrij om te klappen, te delen, kritiek te leveren of enige gedachten over het onderwerp te delen!