Leer programmeren met Rust · Les

Functies en control flow

Leer functies definiëren en `if`/`else`, `loop`, `while` en `for`-expressies gebruiken om de uitvoeringsstroom van uw programma te sturen.

Les 3 van 311 stappen

Functies en control flow is een gratis Leer programmeren met Rust-les op CoddyKit. Dit is les 3 van 3. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Leer programmeren met Rust. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Leer programmeren met Rust bevat in totaal 3 lessen.

Wat zijn functies?

Functies zijn benoemde codeblokken die een specifieke taak uitvoeren. Ze zijn essentieel om je code te structureren en herbruikbaar te maken.

Herbruikbaarheid van code: Schrijf een stukje logica één keer en gebruik het meerdere keren.
Modulariteit: Deel complexe problemen op in kleinere, beheersbare onderdelen.
Leesbaarheid: Geef codeblokken betekenisvolle namen, zodat ze gemakkelijker te begrijpen zijn.

Je eerste Rust-functie

In Rust definieer je een functie met het trefwoord fn. De functie main is het startpunt van elk Rust-programma.

Zo declareer en roep je een eenvoudige functie aan:

fn say_hello() {
    println!("Hello from a function!");
}

fn main() {
    say_hello(); // Call the function
    println!("Back in main.");
}

Functies met parameters

Functies kunnen invoerwaarden accepteren die parameters worden genoemd. Hiermee kan je functie telkens wanneer deze wordt aangeroepen met andere gegevens werken.

Parameters worden gedefinieerd met een naam en een type, gescheiden door een dubbele punt.

fn greet(name: &str) {
    println!("Hello, {}!", name);
}

fn main() {
    greet("Alice");
    greet("Bob");
}

Functies met retourwaarden

Functies kunnen ook een waarde teruggeven aan de aanroeper. Je geeft het retourtype op na een pijl (->).

De laatste expressie in de hoofdtekst van de functie wordt impliciet teruggegeven. Voor de retourexpressie is geen puntkomma nodig!

fn add_numbers(x: i32, y: i32) -> i32 {
    x + y // No semicolon: this expression is returned
}

fn main() {
    let sum = add_numbers(5, 7);
    println!("The sum is: {}", sum);
}

Beslissingen nemen: `if`/`else`

Met de if-expressie kan je programma verschillende codeblokken uitvoeren op basis van een voorwaarde. Voorwaarden moeten altijd een bool zijn (true/false).

Gebruik if voor de eerste voorwaarde.
Gebruik else if voor aanvullende voorwaarden.
Gebruik else als terugvaloptie wanneer aan geen enkele andere voorwaarde is voldaan.

De if van Rust is een expressie, wat betekent dat deze een waarde kan teruggeven!

If-else-expressies in actie

Zo kun je if en else gebruiken om een waarde toe te wijzen op basis van een voorwaarde. Let op dat dit zich gedraagt als een ternaire operator uit andere talen.

fn main() {
    let number = 7;

    let message = if number < 10 {
        "Small number"
    } else {
        "Large number"
    };

    println!("The number is: {}", message);

    let other_num = 15;
    if other_num % 2 == 0 {
        println!("{} is even", other_num);
    } else {
        println!("{} is odd", other_num);
    }
}

Code herhalen: `loop`

Het trefwoord loop maakt een oneindige lus. Dit is handig wanneer je een actie wilt herhalen totdat je expliciet besluit te stoppen.

Gebruik break om de lus te verlaten. Je kunt zelfs een waarde teruggeven vanuit een loop-expressie met break.

fn main() {
    let mut counter = 0;

    let result = loop {
        counter += 1;

        if counter == 10 {
            break counter * 2; // Break and return a value
        }
    };

    println!("The result is {}", result);
}

Voorwaardelijk herhalen: `while`

De while-lus voert een codeblok uit zolang een opgegeven voorwaarde waar blijft. Dit is ideaal wanneer je niet precies weet hoe vaak je de lus moet uitvoeren.

fn main() {
    let mut count = 3;

    while count != 0 {
        println!("{}!", count);
        count -= 1;
    }

    println!("LIFTOFF!!!");
}

Itereren met `for`-lussen

De for-lus wordt gebruikt om over een verzameling items of een bereik van getallen te itereren. Het is de meestgebruikte lusconstructie van Rust, waarmee je code veilig en beknopt blijft.

Deze wordt vaak gebruikt met bereiken (bijvoorbeeld 1..4 voor 1, 2, 3 of 1..=4 voor 1, 2, 3, 4).
Deze werkt met elk type dat de Iterator-trait implementeert.

fn main() {
    // Loop through a range
    for number in 1..4 { // 1, 2, 3
        println!("Number: {}", number);
    }

    // Loop through an array
    let a = [10, 20, 30, 40, 50];
    for element in a.iter() {
        println!("The value is: {}", element);
    }
}

Uitdaging over besturingsstroom

Bekijk de volgende Rust-code. Wat is de uiteindelijke waarde van result?

fn calculate_value(input: i32) -> i32 {
    if input > 10 {
        input * 2
    } else if input == 5 {
        input + 5
    } else {
        input
    }
}

fn main() {
    let result = calculate_value(5);
    // What is result?
}

Beantwoord dit in de interactieve les

Samenvatting: functies en besturingsstroom

Je beheerst de bouwstenen voor dynamische programma's!

Functies: Organiseer en hergebruik code met fn, parameters en retourwaarden.
if/else: Neem beslissingen en voer code voorwaardelijk uit. Onthoud dat dit een expressie is!
loop: Maak oneindige lussen, verlaat ze met break en geef waarden terug.
while: Blijf lussen zolang een voorwaarde waar is.
for: Itereer veilig over verzamelingen en bereiken.

Deze hulpmiddelen zijn essentieel voor het schrijven van gestructureerde en efficiënte Rust-programma's!

Gratis beginnen

Leer Rust 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: 144

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Functies en control flow” gratis?

Ja — je kunt hier op het web alle 3 lessen van het leerpad Leer programmeren met Rust, waaronder “Functies en control flow”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus Leer programmeren met Rust bevat in totaal 3 lessen.

Wat leer ik in “Functies en control flow”?

Leer functies definiëren en `if`/`else`, `loop`, `while` en `for`-expressies gebruiken om de uitvoeringsstroom van uw programma te sturen. Je oefent met Leer programmeren met Rust 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 Leer programmeren met Rust te beginnen?

Ervaring vooraf is niet nodig. Leer programmeren met Rust 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 3 van 3.

Hoe lang duurt de les “Functies en control flow”?

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 Leer programmeren met Rust?

Ja. Elke les over Leer programmeren met Rust 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

Variabelen, veranderlijkheid en shadowing
Primitieve gegevenstypen en operatoren
Functies en control flow

← Terug naar Leer programmeren met Rust