Lær Rust-programmering · leksjon

Definere og bruke structs

Opprett egne datastrukturer med structs, inkludert tuple structs og unit-lignende structs, for å samle relaterte data.

Leksjon 1 av 311 trinn

Definere og bruke structs er en gratis leksjon i Lær Rust-programmering på CoddyKit. Dette er leksjon 1 av 3. Du kan lese valgfritt 3 leksjoner fra denne læringsstien gratis i sin helhet – deretter låser CoddyKit PRO opp alle leksjoner, samt praktisk øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Lær Rust-programmering, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Lær Rust-programmering inneholder totalt 3 leksjoner.

Møt strukturer: egendefinerte datatyper

I Rust er strukturer (kort for strukturerte datatyper) en måte å opprette egendefinerte datatyper på, slik at du kan navngi og samle flere relaterte verdier i en meningsfull gruppe.

Tenk på en struktur som en oppskrift for en bruker, en farge eller et punkt i rommet. I stedet for å ha separate variabler for brukerens navn, e-post og alder kan du samle dem i en User-struktur.

Dette hjelper deg med å organisere dataene logisk og gjør koden enklere å lese og vedlikeholde.

Definere en klassisk struktur

Den vanligste strukturtypen er en klassisk struktur, der du navngir hver del av dataene, kalt et felt. Slik definerer du en:

struct User {
    username: String,
    email: String,
    sign_in_count: u64,
    active: bool,
}

fn main() {
    // This code only defines the struct blueprint.
    // No actual user has been created yet!
    println!("Struct 'User' blueprint defined.");
}

Opprette forekomster av strukturer

Når du har definert en struktur, kan du opprette konkrete forekomster av den. Hver forekomst inneholder bestemte verdier for feltene sine. Du oppretter en forekomst ved å angi konkrete verdier for hvert felt.

struct User {
    username: String,
    email: String,
    sign_in_count: u64,
    active: bool,
}

fn main() {
    let user1 = User {
        email: String::from("alice@example.com"),
        username: String::from("alice123"),
        active: true,
        sign_in_count: 1,
    };
    println!("User instance created!");
}

Få tilgang til strukturfelt

For å hente data fra en strukturforekomst bruker du punktnotasjon. Skriv ganske enkelt navnet på forekomsten, et punktum (.) og deretter feltnavnet.

struct User {
    username: String,
    email: String,
    sign_in_count: u64,
    active: bool,
}

fn main() {
    let user1 = User {
        email: String::from("alice@example.com"),
        username: String::from("alice123"),
        active: true,
        sign_in_count: 1,
    };
    println!("User's username: {}", user1.username);
    println!("User's email: {}", user1.email);
}

Muterbarhet med strukturer

Akkurat som vanlige variabler kan hele strukturforekomster gjøres muterbare ved hjelp av nøkkelordet mut. Hvis en forekomst er muterbar, kan alle feltene endres.

Du kan ikke gjøre bare enkelte felt muterbare; muterbarheten gjelder for strukturforekomsten som helhet.

struct User {
    username: String,
    email: String,
    sign_in_count: u64,
    active: bool,
}

fn main() {
    let mut user1 = User {
        email: String::from("alice@example.com"),
        username: String::from("alice123"),
        active: true,
        sign_in_count: 1,
    };
    
    println!("Old email: {}", user1.email);
    user1.email = String::from("new_alice@example.com");
    println!("New email: {}", user1.email);
}

Tuplestrukturer: navnløse felt

Tuplestrukturer er en annen strukturform som ligner på tupler, men som har et navn. De er nyttige når du vil gi en tuppel et eget typenavn, men ikke trenger å navngi de enkelte feltene.

Color(i32, i32, i32) er for eksempel en navngitt tuppel som samler tre heltall.

struct Color(i32, i32, i32);
struct Point(i32, i32, i32);

fn main() {
    let black = Color(0, 0, 0);
    let origin = Point(0, 0, 0);
    println!("Tuple structs 'Color' and 'Point' defined.");
}

Bruke tuplestrukturer

Å opprette en forekomst av en tuplestruktur ligner på å opprette en vanlig tuppel. For å få tilgang til verdiene bruker du punktnotasjon med indeksen, som starter på 0.

struct Color(i32, i32, i32);
struct Point(i32, i32, i32);

fn main() {
    let black = Color(0, 0, 0);
    let origin = Point(0, 0, 0);

    println!("Black color: R={}, G={}, B={}", black.0, black.1, black.2);
    println!("Origin point: X={}, Y={}, Z={}", origin.0, origin.1, origin.2);
}

Enhetslignende strukturer: markører

Du kan også definere strukturer som ikke har noen felt i det hele tatt. Disse kalles enhetslignende strukturer fordi de oppfører seg omtrent som enhetstypen ().

De brukes ofte som markører for å implementere en bestemt trait for en type, når selve dataene ikke er viktige.

struct AlwaysTrue;

fn main() {
    let subject = AlwaysTrue;
    // Unit-like structs don't store data directly,
    // but they can be instantiated and used as types.
    println!("Unit-like struct 'AlwaysTrue' created.");
}

Syntaks for oppdatering av strukturer

Hvis du trenger å opprette en ny strukturforekomst basert på en eksisterende, men bare vil endre noen feltverdier, tilbyr Rust en praktisk syntaks for oppdatering av strukturer (..).

Denne syntaksen flytter de resterende feltene fra den angitte forekomsten. Derfor kan den opprinnelige forekomsten ikke lenger brukes hvis den inneholder felt som implementerer Copy.

struct User {
    username: String,
    email: String,
    sign_in_count: u64,
    active: bool,
}

fn main() {
    let user1 = User {
        email: String::from("alice@example.com"),
        username: String::from("alice123"),
        active: true,
        sign_in_count: 1,
    };

    let user2 = User {
        email: String::from("bob@example.com"),
        username: String::from("bob456"),
        ..user1 // Copy remaining fields from user1
    };

    println!("User 2 email: {}", user2.email);
    println!("User 2 active: {}", user2.active);
    // user1.username is now moved, so user1 can't be used here.
}

Test om strukturer

Test hvor godt du forstår Rust-strukturer.

Besvar den i den interaktive leksjonen

Oppsummering: Oversikt over strukturer

Du har lært hvordan du definerer og bruker strukturer i Rust!

Klassiske strukturer samler navngitte felt for å opprette egendefinerte datatyper.
Tuplestrukturer er navngitte tupler som er nyttige når feltnavn ikke er strengt nødvendige.
Enhetslignende strukturer har ingen felt og fungerer som markører.
Strukturforekomster kan gjøres mut for å tillate endring av feltene.
Syntaksen .. hjelper deg med å opprette nye forekomster fra eksisterende forekomster.

Strukturer er grunnleggende for å organisere relaterte data i Rust-programmer, og gjør koden mer strukturert og lesbar.

Gratis å komme i gang

Lær deg Rust med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 39
Leksjoner: 144

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Definere og bruke structs» gratis?

Ja – du kan lese valgfritt 3 av leksjonene i læringsstien Lær Rust-programmering, inkludert «Definere og bruke structs», gratis i sin helhet her på nettet. Deretter låser CoddyKit PRO opp alle leksjoner, samt interaktiv øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Kurset i Lær Rust-programmering inneholder totalt 3 leksjoner.

Hva lærer jeg i «Definere og bruke structs»?

Opprett egne datastrukturer med structs, inkludert tuple structs og unit-lignende structs, for å samle relaterte data. Du øver på Lær Rust-programmering med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Lær Rust-programmering?

Ingen tidligere erfaring er nødvendig. Lær Rust-programmering på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 1 av 3.

Hvor lang tid tar leksjonen «Definere og bruke structs»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Lær Rust-programmering-leksjonen?

Ja. Alle Lær Rust-programmering-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

← Tilbake til Lær Rust-programmering