Leer programmeren met Rust · Les

Functies definiëren

Parameters en returnwaarden

Les 1 van 413 stappen

Functies definiëren is een gratis Leer programmeren met Rust-les op CoddyKit. Dit is les 1 van 4. 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 4 lessen.

Een functie declareren

Je definieert een functie met het sleutelwoord fn, een naam, haakjes en een lichaam tussen accolades.

Volgens de conventie gebruikt Rust snake_case voor functienamen.

fn main() {
    greet();
}

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

De functie main

Elk uitvoerbaar Rust-programma begint bij fn main(). Dit is het toegangspunt dat de runtime als eerste aanroept.

fn main() {
    println!("Program starts here");
}

Parameters

Functies kunnen parameters accepteren. Elke parameter moet het type na een dubbele punt declareren.

fn main() {
    print_number(7);
}

fn print_number(x: i32) {
    println!("The number is {}", x);
}

Meerdere parameters

Scheid meerdere parameters met komma's. Elke parameter heeft zijn eigen type-annotatie nodig.

fn main() {
    describe("Rust", 2010);
}

fn describe(name: &str, year: i32) {
    println!("{} was released in {}", name, year);
}

Retourwaarden

Declareer een retourtype na een pijl ->. De functie geeft een waarde van dat type terug.

De laatste expressie, zonder puntkomma, wordt de retourwaarde.

fn main() {
    let result = square(5);
    println!("square is {}", result);
}

fn square(n: i32) -> i32 {
    n * n
}

Het sleutelwoord return

Je kunt ook eerder retourneren met het sleutelwoord return. Dit is handig voor voorwaarden die eerst iets controleren.

fn main() {
    println!("{}", abs_value(-8));
}

fn abs_value(n: i32) -> i32 {
    if n < 0 {
        return -n;
    }
    n
}

Parameters en retourwaarden combineren

Een functie accepteert meestal invoer en produceert uitvoer. Hier tellen we twee getallen op.

fn main() {
    let total = add(3, 4);
    println!("total {}", total);
}

fn add(a: i32, b: i32) -> i32 {
    a + b
}

Functies die functies aanroepen

Functies kunnen andere functies aanroepen, zodat je groter gedrag kunt opbouwen uit kleine, herbruikbare onderdelen.

fn main() {
    println!("{}", double_then_add(5));
}

fn double(n: i32) -> i32 { n * 2 }

fn double_then_add(n: i32) -> i32 {
    double(n) + 1
}

Andere typen retourneren

Functies kunnen elk type retourneren: tekenreeksen, booleaanse waarden, tuples en meer.

fn main() {
    let (sum, product) = compute(3, 4);
    println!("sum {} product {}", sum, product);
}

fn compute(a: i32, b: i32) -> (i32, i32) {
    (a + b, a * b)
}

Functies zonder retourwaarde

Een functie zonder pijl retourneert het unit-type (). De functie doet haar werk via bijwerkingen, zoals afdrukken.

fn main() {
    log_message("saving file");
}

fn log_message(msg: &str) {
    println!("[LOG] {}", msg);
}

De volgorde maakt niet uit

In tegenstelling tot sommige talen kun je in Rust een functie aanroepen die later in het bestand is gedefinieerd. De compiler ziet alle functies voordat het programma wordt uitgevoerd.

fn main() {
    println!("{}", helper());
}

fn helper() -> i32 {
    99
}

Korte controle

Haal je herinnering op aan de manier waarop Rust-functies waarden retourneren.

Beantwoord dit in de interactieve les

Samenvatting

Functies in Rust:

Worden gedefinieerd met fn name(params) -> ReturnType { ... }.
Parameters hebben expliciete typen nodig.
De laatste expressie, zonder puntkomma, is de retourwaarde; je kunt ook eerder return gebruiken.
Zonder retourtype retourneert de functie ().

fn main() {
    let area = rectangle_area(4, 6);
    println!("area {}", area);
}

fn rectangle_area(w: i32, h: i32) -> i32 {
    w * h
}

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 definiëren” gratis?

Ja — je kunt hier op het web alle 3 lessen van het leerpad Leer programmeren met Rust, waaronder “Functies definiëren”, 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 4 lessen.

Wat leer ik in “Functies definiëren”?

Parameters en returnwaarden 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 1 van 4.

Hoe lang duurt de les “Functies definiëren”?

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

← Terug naar Leer programmeren met Rust