De basis van recursie
Recursieve functies
De basis van recursie 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.
Wat is recursie
Recursie betekent dat een functie zichzelf aanroept om een kleinere versie van hetzelfde probleem op te lossen. Dit past goed bij functioneel programmeren en vervangt veel lussen door definities die naar zichzelf verwijzen.
Twee essentiële onderdelen
Elke correcte recursieve functie heeft nodig:
- een basisgeval dat de recursie stopt;
- een recursief geval dat naar het basisgeval toe werkt.
Zonder een bereikbaar basisgeval blijft de recursie oneindig doorgaan.
Faculteit
Het klassieke voorbeeld: n! = n * (n-1)!, met 0! = 1 als basisgeval.
object Main {
def factorial(n: Int): Int =
if (n <= 1) 1
else n * factorial(n - 1)
def main(args: Array[String]): Unit = {
println(factorial(5))
}
}De aanroepen volgen
Elke recursieve aanroep pauzeert en wacht op het resultaat van de binnenste aanroep. factorial(3) wordt uitgebreid tot 3 * (2 * (1)). De vermenigvuldigingen vinden plaats wanneer de aanroepen terugkeren.
object Main {
def factorial(n: Int): Int = {
println(s"entering factorial($n)")
if (n <= 1) 1 else n * factorial(n - 1)
}
def main(args: Array[String]): Unit = {
println("result = " + factorial(3))
}
}Som van een lijst
Recursie over een lijst: de som is de kop plus de som van de staart, waarbij de lege lijst de som nul heeft.
object Main {
def sum(xs: List[Int]): Int = xs match {
case Nil => 0
case h :: t => h + sum(t)
}
def main(args: Array[String]): Unit = {
println(sum(List(1, 2, 3, 4)))
}
}Lengte van een lijst
Met hetzelfde patroon bereken je de lengte: leeg is 0, anders is het 1 plus de lengte van de staart.
object Main {
def length[A](xs: List[A]): Int = xs match {
case Nil => 0
case _ :: t => 1 + length(t)
}
def main(args: Array[String]): Unit = {
println(length(List("a", "b", "c")))
}
}De aanroepstack
Elke wachtende recursieve aanroep gebruikt een stackframe. Bij diepe recursie stapelen veel frames zich op. Bij zeer grote invoer kan de stack daardoor vollopen en een StackOverflowError veroorzaken.
Fibonacci
Sommige problemen vertakken zich in meerdere recursieve aanroepen. Fibonacci roept zichzelf twee keer aan. Dat is elegant, maar de kosten groeien exponentieel.
object Main {
def fib(n: Int): Int =
if (n < 2) n
else fib(n - 1) + fib(n - 2)
def main(args: Array[String]): Unit = {
println(fib(10))
}
}Een lijst omkeren
Recursie kan nieuwe structuren opbouwen: reverse voegt de kop achter de omgekeerde staart toe.
object Main {
def reverse[A](xs: List[A]): List[A] = xs match {
case Nil => Nil
case h :: t => reverse(t) :+ h
}
def main(args: Array[String]): Unit = {
println(reverse(List(1, 2, 3)))
}
}Recursie versus iteratie
Lussen wijzigen een teller; recursie drukt het probleem declaratief uit. Beide zijn geldig. Recursie is sterk bij boomvormige gegevens en verdeel-en-heers, maar naïeve recursie kan bij grote lineaire invoer de stack laten overlopen.
Grootste gemene deler
Het algoritme van Euclides is van nature recursief en convergeert snel.
object Main {
def gcd(a: Int, b: Int): Int =
if (b == 0) a else gcd(b, a % b)
def main(args: Array[String]): Unit = {
println(gcd(48, 18))
}
}Korte toets
Toets je basiskennis van recursie.
Samenvatting
Je hebt de basisprincipes van recursie geleerd:
- Elke recursieve functie heeft een basisgeval en een recursief geval nodig.
- Elke wachtende aanroep gebruikt een stackframe; diepe recursie kan de stack laten overlopen.
- Recursie drukt algoritmen voor lijsten en bomen op natuurlijke wijze uit.
Vervolgens maak je recursie stackveilig met de annotatie @tailrec.
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 “De basis van recursie” gratis?
Ja — de volledige tekst van “De basis van recursie” 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 “De basis van recursie”?
Recursieve functies 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 “De basis van recursie”?
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
- De basis van recursie
- De annotatie tailrec
- Accumulatorpatroon
- Trampolining