Lär dig programmera i Rust · Lektion

Sammansatta typer

Tupler och arrayer

Lektion 3 av 413 steg

Sammansatta typer är en gratis lektion i Lär dig programmera i Rust på CoddyKit. Detta är lektion 3 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för Lär dig programmera i Rust, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Lär dig programmera i Rust innehåller totalt 4 lektioner.

Vad är sammansatta typer?

Sammansatta typer grupperar flera värden till ett enda. Rust har två primitiva sammansatta typer:

Tup overall? — grupper med fast storlek som kan innehålla olika typer.
Arrayer — grupper med fast storlek som innehåller samma typ.

fn main() {
    let tup = (1, 2.0, 'c');
    let arr = [10, 20, 30];
    println!("{} {}", tup.0, arr[0]);
}

Skapa tupler

En tupel samlar värden inom parenteser. Varje element kan ha en annan typ.

Tupelns typ är kombinationen av elementens typer.

fn main() {
    let person: (&str, u32, f64) = ("Alice", 30, 5.6);
    println!("{} is {} years old", person.0, person.1);
}

Åtkomst till tupelns element

Kom åt tupelns element med ett index efter en punkt, med början på 0.

tup.0 är det första elementet.
tup.1 är det andra.

fn main() {
    let point = (3, 7);
    let x = point.0;
    let y = point.1;
    println!("x={} y={}", x, y);
}

Destrukturera tupler

Ni kan dela upp en tupel i separata variabler i ett enda steg. Detta kallas destrukturering.

fn main() {
    let coords = (1.5, 2.5, 3.5);
    let (a, b, c) = coords;
    println!("{} {} {}", a, b, c);
}

Unit-typen

En tom tupel () kallas unit-typen. Den representerar ”inget meningsfullt värde”.

Funktioner som inte returnerar något returnerar egentligen ().

fn main() {
    let nothing = ();
    println!("unit value is {:?}", nothing);
}

Skapa arrayer

En array innehåller flera värden av samma typ och har en fast längd. Den skrivs inom hakparenteser.

Typen är [type; length].

fn main() {
    let days: [&str; 3] = ["Mon", "Tue", "Wed"];
    let numbers = [1, 2, 3, 4, 5];
    println!("{} {}", days[1], numbers[4]);
}

Indexering av arrayer

Kom åt element i en array med hakparenteser och ett nollbaserat index.

Om ni använder ett index utanför arrayens gränser uppstår en panic vid körning — Rust kontrollerar gränserna av säkerhetsskäl.

fn main() {
    let colors = ["red", "green", "blue"];
    println!("first {}", colors[0]);
    println!("last {}", colors[2]);
}

Upprepade startvärden

Fyll en array med samma värde genom att använda [value; count].

Detta skapar en array med count element som alla är lika med value.

fn main() {
    let zeros = [0; 5];
    println!("{:?}", zeros);
    println!("length is {}", zeros.len());
}

Arrayens längd

Metoden .len() returnerar antalet element i en array. Längden är fast vid kompilering.

Om ni behöver en lista som kan växa använder ni i stället en Vec.

fn main() {
    let scores = [88, 92, 75, 100];
    println!("there are {} scores", scores.len());
}

Iterera över en array

Använd en for-loop för att gå igenom varje element i en array i ordning.

fn main() {
    let nums = [2, 4, 6, 8];
    let mut sum = 0;
    for n in nums {
        sum += n;
    }
    println!("sum = {}", sum);
}

Tupler jämfört med arrayer

När ska ni använda de olika typerna?

Använd en tupel för en fast grupp med olika typer, till exempel en koordinat och en etikett.
Använd en array för en fast grupp med samma typ, till exempel en lista med poäng.

fn main() {
    let record = ("Bob", [90, 85, 95]);
    println!("{} first score {}", record.0, (record.1)[0]);
}

Snabbtest

Välj det korrekta påståendet om Rusts sammansatta typer.

Besvara frågan i den interaktiva lektionen

Sammanfattning

Rusts sammansatta typer:

Tupler — (a, b, c), blandade typer, åtkomst via .0, kan destruktureras.
Arrayer — [a, b, c], samma typ, fast längd, åtkomst via [index].
() är unit-typen.

fn main() {
    let (name, scores) = ("Cara", [70, 80, 90]);
    let mut total = 0;
    for s in scores {
        total += s;
    }
    println!("{} total {}", name, total);
}

Gratis att börja

Lär dig Rust med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 39
Lektioner: 144

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Sammansatta typer” gratis?

Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Lär dig programmera i Rust, inklusive ”Sammansatta typer”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i Lär dig programmera i Rust innehåller totalt 4 lektioner.

Vad lär jag mig i ”Sammansatta typer”?

Tupler och arrayer Ni övar på Lär dig programmera i Rust med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Lär dig programmera i Rust?

Du behöver inga förkunskaper. Utbildningen i Lär dig programmera i Rust på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 3 av 4.

Hur lång tid tar lektionen ”Sammansatta typer”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Lär dig programmera i Rust-lektionen?

Ja. Varje Lär dig programmera i Rust-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till Lär dig programmera i Rust