Wat is een zuivere functie?
Nou, een pure functie ziet er zo uit, we hebben een functie, dus in plaats van een doos die we eerder hadden van
objecten met al deze functionaliteiten, beschouw dit in plaats daarvan als een simpele functie.
En laten we zeggen dat we het een lijst geven met één, twee en drie.
Als we deze invoer in deze functie geven, zouden we bij een pure functie verwachten dat er iets
met deze invoer gebeurt dat elke keer hetzelfde resultaat oplevert.
Dus laten we zeggen dat we dit met twee vermenigvuldigen, we zouden twee, vier en zes krijgen.
Nu heeft een zuivere functie twee regels.
Een daarvan is dat, gegeven dezelfde invoer, het altijd dezelfde uitvoer zal retourneren, dat wil zeggen, elke keer dat we een, twee en drie
aan deze lijst geven, geven we het aan een functie die we maken.
Het moet altijd dezelfde output retourneren.
Dus als ik deze functie miljoenen keren met dezelfde invoer uitvoer, zou dit dezelfde uitvoer moeten opleveren.
En het tweede punt is dat dit idee van een functie geen bijwerkingen mag veroorzaken.
Wat zijn bijwerkingen?
Bijwerkingen zijn dingen die een functie hebben.
Heeft dat gevolgen voor de buitenwereld?
Als ik bijvoorbeeld iets binnen deze functie zou afdrukken, heeft dat invloed op de buitenwereld, toch?
Omdat ik iets op een scherm print.
Het scherm is de buitenwereld.
Of, bijvoorbeeld, als deze functie een variabele aanraakte die buiten een ander bereik leefde, is dat
een bijwerking.
Laten we eens kijken.
Een code om dit concept een beetje meer te begrijpen.
Laten we zeggen dat we een functie hadden en dan zal deze functie zich vermenigvuldigen.
Door naar een lijst, dus laten we zeggen een bondgenoot, wat onze lijst zal zijn, en hier willen
we het item overlopen.
Als laatste.
En dan elk item dat we willen vermenigvuldigen en toevoegen aan een nieuwe lijst.
Laten we dus een nieuwe lijst maken die een lege lijst zal zijn.
En hier zullen we zeggen nieuwe lijst, punt toevoegen.
En doe het in vermenigvuldig met twee.
En tot slot, aan het einde van deze functie, willen we de nieuwe lijst retourneren.
Laten we dit eens proberen.
Als ik zeg vermenigvuldig met twee en geef het een, twee, drie en laten we het uitprinten.
Hier de uitvoer.
Als ik klik, ren dan weg.
Ik krijg twee, vier, zes.
Is dit een pure functie, laten we hier eens over nadenken.
De eerste regel krijgt dezelfde invoer, dat wil zeggen één, twee en drie.
Het zal altijd dezelfde output retourneren, hoe vaak ik dit ook doe, het zal me
altijd dezelfde output geven.
Dus, oké, we zijn geslaagd voor de eerste test.
Hoe zit het met de tweede test dat het geen bijwerkingen veroorzaakt?
Levert dit bijwerkingen op?
Raakt dit iets in de buitenwereld?
Denk er over na.
Nee, het schrijft niets in de buitenwereld dat belangrijk is voor deze functie.
Want alles zit erin.
Als we bijvoorbeeld in plaats van hier print hebben, hebben we gewoon print.
En hier.
Als ik klik, ren dan weg.
We krijgen dezelfde output, maar heeft dit bijwerkingen?
Nou ja, dat doet het wel.
Het staat in wisselwerking met de buitenwereld, wat het printstatement is.
De afdrukverklaring zegt me, hey, ik ga afdrukken op wat het display van deze machine ook heeft.
In ons geval wordt het hier afgedrukt, maar we weten niet echt wat het afdrukstatement doet, omdat het in
wisselwerking staat met het scherm aan deze kant.
Dus dit.
Bijwerkingen, we geven controle over printen, maar we weten niet wat print gaat doen.
Nog een voorbeeld dat ik je kan geven.
Is dit wat als we hier een nieuwe lijst hebben die we daadwerkelijk buiten definiëren?
Zoals zo.
Zodat we een nieuwe lijst hebben zoals deze, als ik op uitvoeren klik.
Ik kom nog steeds op vier, zes, maar heeft dit bijwerkingen?
Nou ja, dat doet het wel.
Het interageert met de buitenwereld en wat er buiten deze wereld van een functie is die zich
herinnert, is de reikwijdte, nou ja, het werkt samen met deze nieuwe lijst.
Het gebeurt met deze nieuwe lijst.
Dus als er een programmeur langskomt en misschien voordat we deze functie uitvoeren, besluiten we een nieuwe lijst te zeggen.
We veranderen het in een lege string.
Nou, als ik deze functie uitvoer.
Ik krijg een foutmelding omdat deze nieuwe lijst nu een stringobject is.
Dus de nieuwe lijst die in de buitenwereld van deze functie leeft, kan worden aangepast door een andere ontwikkelaar of door een
programma en we zouden er niets van weten.
En wanneer we deze functie uitvoeren, geeft het ons een foutmelding.
Het heeft een bijwerking.
Dus idealiter bevatten we onze functies.
En maak ze puur, want, zoals je kunt zien, zullen we nooit een bug of fout in onze code hebben, tenzij we
hier iets verkeerds hebben geschreven, maar omdat we niet om de buitenwereld geven, omdat alles wat
we geven, aangezien een input altijd een goede output zal opleveren, zal het puur zijn.
Nu is het moeilijk om echt te begrijpen waarom dit zo'n krachtig concept is zonder een beetje ervaring op de
werkplek.
Maar laat me je dit vertellen, dat wanneer je pure functies hebt.
Je hebt minder buggy-code, je kunt je code beter testen.
Het is gemakkelijker om uw code en in het algemeen te begrijpen.
Je hebt deze voordelen door geen verschillende delen van je code te hebben, elkaar aan te raken en
elkaar te beïnvloeden, wat je leven als programmeur zoveel gemakkelijker maakt.
Dus dit idee van pure functies is erg belangrijk.
Maar het enige dat ik wil dat je hieruit haalt, is dat pure functies meer een richtlijn zijn dan
een absoluut.
Het is onmogelijk om overal pure functies te hebben, want als een functie de buitenwereld helemaal niet beïnvloedt, nou,
dan zouden we geen programma's hebben.
We zouden niet in staat zijn om dingen te laten zien.
We zouden dingen zoals ons gameprofiel niet kunnen opslaan.
Het is dus onmogelijk om overal pure functies te hebben.
Echter, wanneer u kunt waar u maar kunt, leert functioneel programmeren ons dat uw functies goed zijn.
Probeer pure functies te maken en heb slechts enkele niet-pure functies die misschien interageren met de buitenwereld waar
we naar terug kunnen gaan wanneer we bugs in onze code hebben, want hoogstwaarschijnlijk zijn dat
degenen die bugs zullen hebben dan pure functies zoals dit om ons concept van functioneel programmeren af te ronden.
Als dit bijvoorbeeld onze wizard was uit de vorige video's met functioneel programmeren, zouden we
een wizard-object hebben.
Of Wizzard-woordenboek met een naam.
Laten we zeggen Marlon.
En macht.
Van 50.
En in plaats van deze in een klasse op te nemen, zou ik verschillende methoden hebben, zoals aanvallen.
En dit zou geen methode zijn, het zou een functie zijn omdat het niet in een klasse leeft.
Bij functioneel programmeren zeggen ze, hé, we hoeven geen gegevens met functies te combineren, laten we die
gescheiden houden, laten we gewoon pure functies maken die zoiets als een teken kunnen worden doorgegeven.
En op deze manier houden we die twee dingen gescheiden zodat we ons kunnen concentreren op pure functies en we
kunnen focussen op data, dus daar zit het verschil.
Uiteindelijk draait het allemaal om proberen onze jas schoon te houden en insecten in onze jas te vermijden, een groot
probleem waar programmeurs altijd mee te maken hebben.
Het is dus gewoon een andere manier van denken.
Laten we wat meer leren in de volgende video.