Lær at programmere i Rust · Lektion

String kontra &str

Ejerskab af tekst

Lektion 1 af 413 trin

String kontra &str er en gratis Lær at programmere i Rust-lektion på CoddyKit. Dette er lektion 1 af 4. Du kan læse alle 3 lektioner i dette læringsspor gratis i deres fulde længde — derefter låser CoddyKit PRO alle lektioner op samt praktiske øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Den er en del af læringsforløbet i Lær at programmere i Rust, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Lær at programmere i Rust-kurset indeholder 4 lektioner i alt.

Ejet og lånt tekst

Rust opdeler tekst-ejerskab i to typer:

String — ejer sine data på heapen.
&str — låner en visning af tekst, som den ikke ejer.

fn main() {
    let owned = String::from("I own this");
    let borrowed: &str = "I am borrowed";
    println!("{} / {}", owned, borrowed);
}

Hvor dataene ligger

En String gemmer sine bytes på heapen og kan vokse. En strengliteral &str er indlejret i programmets binærfil og har en fast størrelse.

fn main() {
    let mut heap = String::from("grows");
    heap.push_str(" bigger");
    let fixed = "never changes";
    println!("{} | {}", heap, fixed);
}

Ejerskab betyder ansvar

Ejeren af en String frigiver dens hukommelse, når den går ud af scope. En &str ejer ingenting og frigiver derfor aldrig noget.

fn main() {
    {
        let s = String::from("temporary");
        println!("{}", s);
    } // s is dropped and its memory freed here
    println!("done");
}

Sådan låner du en String

Du kan låne en String som en &str ved hjælp af &. String ejer stadig dataene; slicen ser kun på dem.

fn main() {
    let owned = String::from("shared text");
    let view: &str = &owned;
    println!("{} / {}", owned, view);
}

Sådan flytter du en String

Når du tildeler en String til en anden variabel, flyttes ejerskabet. Den oprindelige værdi kan ikke længere bruges.

fn main() {
    let a = String::from("hello");
    let b = a; // ownership moves to b
    // println!("{}", a); // would error: a was moved
    println!("{}", b);
}

Kloning for at beholde begge

Hvis du har brug for to uafhængige ejede strenge, skal du bruge clone til at kopiere dataene.

fn main() {
    let a = String::from("hello");
    let b = a.clone();
    println!("{} and {}", a, b);
}

Det er billigt at kopiere en &str

En &str består blot af en pointer og en længde, så kopiering af den kopierer ikke den underliggende tekst. Den implementerer Copy.

fn main() {
    let original = "data";
    let copy = original; // both still valid
    println!("{} {}", original, copy);
}

Funktioner og ejerskab

Når du sender en String som værdi, flyttes den ind i funktionen. Når du sender &str eller &String, låner funktionen kun værdien, så kalders værdi stadig kan bruges.

fn length(s: &str) -> usize {
    s.len()
}

fn main() {
    let text = String::from("measure me");
    println!("{}", length(&text));
    println!("still here: {}", text);
}

Returnering af ejede strenge

Når en funktion skal frembringe ny tekst, returnerer den en ejet String, så kalderen overtager ejerskabet.

fn make_greeting(name: &str) -> String {
    format!("Hello, {}!", name)
}

fn main() {
    let g = make_greeting("Rust");
    println!("{}", g);
}

Valg af den rigtige type

Retningslinjer:

Skal du gemme ejet tekst? Brug String.
Skal du kun læse eller sende tekst videre? Accepter &str.
Skal du opbygge ny tekst i en funktion? Returnér String.

fn first_word(s: &str) -> &str {
    s.split_whitespace().next().unwrap_or("")
}

fn main() {
    let sentence = String::from("learn rust today");
    println!("{}", first_word(&sentence));
}

Hvorfor forskellen er vigtig

Denne opdeling lader Rust undgå unødvendige kopier og garanterer hukommelsessikkerhed uden en garbage collector. Du ved altid, hvem der ejer et stykke tekst.

fn main() {
    let owned = String::from("safe");
    let borrowed = &owned[..];
    println!("owner {} borrows {}", owned, borrowed);
}

Hurtigt tjek

Husk, hvad der sker, når du flytter en String.

Besvar den i den interaktive lektion

Opsummering

Ejerskab for String sammenlignet med &str:

String ejer data på heapen og frigiver dem ved drop.
&str låner eksisterende tekst og ejer ingenting.
Når en String flyttes, bliver den oprindelige værdi ugyldig; clone kopierer den.
Acceptér &str for at læse, og returnér String for at frembringe ny tekst.

fn shout(s: &str) -> String {
    s.to_uppercase()
}

fn main() {
    let name = String::from("rust");
    let loud = shout(&name);
    println!("{} -> {}", name, loud);
}

Gratis at komme i gang

Lær Rust med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser: 39
Lektioner: 144

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “String kontra &str” gratis?

Ja — alle 3 lektioner i læringssporet Lær at programmere i Rust, inklusive “String kontra &str”, kan læses gratis i deres fulde længde her på webstedet. Derefter låser CoddyKit PRO alle lektioner op samt interaktive øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Lær at programmere i Rust-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “String kontra &str”?

Ejerskab af tekst Du øver dig i Lær at programmere i Rust med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på Lær at programmere i Rust?

Der kræves ingen tidligere erfaring. Lær at programmere i Rust på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 1 af 4.

Hvor lang tid tager lektionen “String kontra &str”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne Lær at programmere i Rust-lektion?

Ja. Alle Lær at programmere i Rust-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

← Tilbage til Lær at programmere i Rust