Geef je waarden een naam

Je maakt pakketjes met ansichtkaarten voor een evenement. Het aantal pakketjes en het aantal kaarten per pakket bepalen de voorraad. Met namen voor die getallen wordt de berekening leesbaar en kun je de uitkomst voor een volgende stap gebruiken.

Een waarde aan een naam binden

Met let geef je in Rust een waarde een naam. let packs = 4; koppelt de naam packs aan het getal vier. Dit heet een binding; in deze lessen gebruiken we daarvoor ook het woord variabele.

Het teken = betekent hier dat de waarde rechts aan de naam links wordt toegekend. De puntkomma sluit de instructie af. Je kunt de naam daarna gebruiken om die bewaarde waarde te lezen.

Rust heeft typen: afspraken over welke soort waarde iets is. In deze kleine getalberekeningen leidt de compiler het gehele-getaltype af, zodat je het niet apart hoeft te schrijven. Een geheel getal heeft geen breukdeel.

Een tussenuitkomst uitrekenen

Een operator beschrijft een bewerking. * vermenigvuldigt, + telt op en - trekt af. In let stock = packs * per_pack; worden de huidige waarden vermenigvuldigd en wordt de uitkomst bij stock bewaard.

We schrijven een naam met meerdere woorden hier met een onderstreping, zoals per_pack. Dat maakt de bedoeling leesbaar. De naam is code en staat dus zonder aanhalingstekens wanneer je haar waarde wilt gebruiken.

Getallen tonen met println!

De macro println! kent invulplaatsen in de tekst. Bij println!("{stock}"); leest Rust de naam tussen accolades en toont haar waarde. De tekst bevat hier alleen die ene invulplaats, zodat je alleen het getal ziet.

Voor een berekening gebruik je een lege invulplaats {} en zet je de berekening na een komma. println!("{}", stock - 3); rekent eerst en toont daarna de uitkomst. De oorspronkelijke waarde van stock verandert hierdoor niet.

Voorspel in het voorbeeld de voorraad en het aantal kaarten nadat er drie voor een proefpakket apart worden gehouden. Voer daarna het volledige programma uit.

fn main() {
    let packs = 4;
    let per_pack = 6;
    let stock = packs * per_pack;
    println!("{stock}");
    println!("{}", stock - 3);
}

24
21

Veelgemaakte fout: opnieuw toekennen zonder mut

Een gewone let-binding is standaard onveranderlijk: je mag er niet later met = een andere waarde aan toekennen. Rust vraagt je daarmee zichtbaar te maken welke namen tijdens de uitvoering moeten kunnen veranderen. De volgende variant probeert toch een nieuw getal toe te kennen.

fn main() {
    let stock = 24;
    println!("{stock}");
    stock = 30;
    println!("{stock}");
}

cannot assign twice to immutable variable

De compiler meldt cannot assign twice to immutable variable: je probeert voor de tweede keer aan een onveranderlijke variabele toe te kennen. Omdat het programma niet compileert, verschijnt ook het eerste getal nog niet. De controle gebeurt vóór de uitvoering.

Als veranderen nodig is, schrijf je bij het aanmaken mut, bijvoorbeeld let mut stock = 24;. Daarna mag stock = 30; de bewaarde waarde vervangen. In de oefening is dat niet nodig: je berekent één totaal en toont daaruit twee uitkomsten.

Bereken een aankoopbedrag

Gebruik de gegeven prijs en hoeveelheid om total te bepalen. Toon die bewaarde waarde en bereken daarna het bedrag na korting voor de tweede regel. Lees de voorbeeldcode terug om te kiezen tussen een naam in de tekst en een berekening na de komma.

Een tussenuitkomst bewaart de waarde van dat moment; zij is geen formule die zichzelf opnieuw uitvoert. Door iedere stap in volgorde te lezen, kun je daarom voorspellen wat de uitvoer wordt. Controleer de operator en het gevraagde kortingsbedrag afzonderlijk.

Wat je meeneemt

• let bindt hier een waarde aan een naam; zonder mut kun je die niet opnieuw toekennen.
• Operatoren rekenen met waarden en een tussenuitkomst bewaart het resultaat.
• println! kan een naam invullen of een berekende waarde via {} tonen.

Hierna combineer je invulplaatsen met volledige zinnen.