‫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 uitvoer 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, het interageert 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.