Functies als waarden
Functies als first-class waarden
Functies als waarden is een gratis Scala voor backend-engineering en functioneel programmeren-les op CoddyKit. Dit is les 1 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Scala voor backend-engineering en functioneel programmeren. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Scala voor backend-engineering en functioneel programmeren bevat in totaal 4 lessen.
Functies zijn waarden
In Scala zijn functies eersteklas waarden. Je kunt ze opslaan in variabelen, als argumenten doorgeven en vanuit andere functies teruggeven, net als getallen of tekenreeksen.
object Main {
def main(args: Array[String]): Unit = {
val increment: Int => Int = x => x + 1
println(increment(5))
}
}Syntaxis van functietypen
Het type Int => String betekent een functie die een Int als invoer neemt en een String teruggeeft. Voor meerdere parameters gebruik je haakjes: (Int, Int) => Int.
object Main {
def main(args: Array[String]): Unit = {
val add: (Int, Int) => Int = (a, b) => a + b
val label: Int => String = n => s"value=$n"
println(add(3, 4))
println(label(7))
}
}Syntaxis van lambda's (anonieme functies)
Een anonieme functie, of lambda, schrijf je als (params) => body. De functie heeft geen naam en wordt vaak rechtstreeks aan een andere functie doorgegeven.
object Main {
def main(args: Array[String]): Unit = {
val square = (x: Int) => x * x
println(square(6))
}
}Functies van hogere orde
Een functie van hogere orde is een functie die een functie als parameter neemt of een functie teruggeeft. map en filter zijn klassieke voorbeelden.
object Main {
def applyTwice(f: Int => Int, x: Int): Int = f(f(x))
def main(args: Array[String]): Unit = {
println(applyTwice(_ + 3, 10))
}
}Functies aan methoden doorgeven
Methoden van verzamelingen accepteren functies. Je kunt een lambda inline doorgeven of een benoemde functiewaarde gebruiken.
object Main {
def main(args: Array[String]): Unit = {
val triple = (x: Int) => x * 3
println(List(1, 2, 3).map(triple))
println(List(1, 2, 3).map(x => x * 3))
}
}Functies teruggeven
Een functie kan een andere functie teruggeven. Hier geeft multiplier een functie terug die met een vaste factor vermenigvuldigt: een kleine functie-fabriek.
object Main {
def multiplier(factor: Int): Int => Int = x => x * factor
def main(args: Array[String]): Unit = {
val timesTen = multiplier(10)
println(timesTen(5))
}
}Methoden versus functies
Met def definieer je een methode. Je kunt een methode omzetten in een functiewaarde met de underscore voor eta-expansie: methodName _, of door de methode simpelweg te gebruiken waar een functie wordt verwacht.
object Main {
def doubleIt(x: Int): Int = x * 2
def main(args: Array[String]): Unit = {
val f: Int => Int = doubleIt
println(f(8))
println(List(1, 2, 3).map(doubleIt))
}
}Functies zonder parameters
Een functie kan geen argumenten aannemen. Het type wordt geschreven als () => T. Dit is nuttig om een berekening uit te stellen.
object Main {
def main(args: Array[String]): Unit = {
val greeting: () => String = () => "Hello!"
println(greeting())
}
}Functies opslaan in verzamelingen
Omdat functies waarden zijn, kun je ze opslaan in lijsten of kaarten en ze dynamisch opzoeken, waarmee je een kleine opdrachtverdeler bouwt.
object Main {
def main(args: Array[String]): Unit = {
val ops: Map[String, (Int, Int) => Int] = Map(
"add" -> (_ + _),
"mul" -> (_ * _)
)
println(ops("add")(3, 4))
println(ops("mul")(3, 4))
}
}Functies als configuratie
Door een functie door te geven, kunnen aanroepers het gedrag aanpassen. Hier past een algemene transformAll een willekeurige functie toe op een lijst.
object Main {
def transformAll(xs: List[Int], f: Int => Int): List[Int] = xs.map(f)
def main(args: Array[String]): Unit = {
println(transformAll(List(1, 2, 3), _ + 100))
println(transformAll(List(1, 2, 3), _ * 10))
}
}Een duidelijker voorbeeld van aanpassing
Hier is hetzelfde idee op een nette manier geschreven: aanroepers leveren de transformatie, waardoor de hulpfunctie algemeen en herbruikbaar blijft.
object Main {
def transformAll(xs: List[Int], f: Int => Int): List[Int] = xs.map(f)
def main(args: Array[String]): Unit = {
println(transformAll(List(1, 2, 3), x => x + 100))
println(transformAll(List(1, 2, 3), x => x * x))
}
}Korte controle
Wat is een functie van hogere orde?
Samenvatting
Je hebt geleerd dat functies eersteklas waarden zijn:
- Sla functies op in
vals, lijsten en kaarten - Functietypen zoals
Int => String - Lambda's:
(x) => bodyen de afkorting met_ - Functies van hogere orde nemen functies aan of geven functies terug
- Methoden worden functiewaarden via eta-expansie
Leer Scala met een AI-tutor — gratis
Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.
- Cursussen
- 39
- Lessen
- 143
Veelgestelde vragen
Is de les “Functies als waarden” gratis?
Ja — de volledige tekst van “Functies als waarden” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus Scala voor backend-engineering en functioneel programmeren wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Scala voor backend-engineering en functioneel programmeren bevat in totaal 4 lessen.
Wat leer ik in “Functies als waarden”?
Functies als first-class waarden Je oefent met Scala voor backend-engineering en functioneel programmeren door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.
Heb ik ervaring nodig om met Scala voor backend-engineering en functioneel programmeren te beginnen?
Ervaring vooraf is niet nodig. Scala voor backend-engineering en functioneel programmeren op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 1 van 4.
Hoe lang duurt de les “Functies als waarden”?
De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.
Kan ik code schrijven en uitvoeren in deze les over Scala voor backend-engineering en functioneel programmeren?
Ja. Elke les over Scala voor backend-engineering en functioneel programmeren bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.
Alle lessen in deze cursus
- Functies als waarden
- Currying
- Compositie
- Closures