String jämfört med &str
Ägarskap för text
String jämfört med &str är en gratis lektion i Lär dig programmera i Rust på CoddyKit. Detta är lektion 1 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.
Ägda och lånade textvärden
Rust skiljer mellan text med ägarskap genom två typer:
String— äger sina data på heapen.&str— lånar en vy av text som den inte äger.
fn main() {
let owned = String::from("I own this");
let borrowed: &str = "I am borrowed";
println!("{} / {}", owned, borrowed);
}Var data finns
En String lagrar sina byte på heapen och kan växa. En strängliteral av typen &str är inbyggd i programmets binärfil och har en fast storlek.
fn main() {
let mut heap = String::from("grows");
heap.push_str(" bigger");
let fixed = "never changes";
println!("{} | {}", heap, fixed);
}Ägarskap innebär ansvar
Ägaren till en String frigör dess minne när den lämnar sitt scope. En &str äger ingenting och frigör därför aldrig något.
fn main() {
{
let s = String::from("temporary");
println!("{}", s);
} // s is dropped and its memory freed here
println!("done");
}Låna en String
Ni kan låna en String som en &str med hjälp av &. String-objektet äger fortfarande datan; slicen tittar bara på den.
fn main() {
let owned = String::from("shared text");
let view: &str = &owned;
println!("{} / {}", owned, view);
}Flytta en String
När en String tilldelas till en annan variabel flyttas ägarskapet. Originalet kan inte längre användas.
fn main() {
let a = String::from("hello");
let b = a; // ownership moves to b
// println!("{}", a); // would error: a was moved
println!("{}", b);
}Klona för att behålla båda
Om ni behöver två fristående ägda strängar använder ni clone för att kopiera datan.
fn main() {
let a = String::from("hello");
let b = a.clone();
println!("{} and {}", a, b);
}Det är billigt att kopiera en &str
En &str består bara av en pekare och en längd, så när den kopieras kopieras inte den underliggande texten. Den implementerar Copy.
fn main() {
let original = "data";
let copy = original; // both still valid
println!("{} {}", original, copy);
}Funktioner och ägarskap
När en String skickas med värde flyttas den in i funktionen. När &str eller &String skickas lånas den bara, så anroparens värde kan fortfarande användas.
fn length(s: &str) -> usize {
s.len()
}
fn main() {
let text = String::from("measure me");
println!("{}", length(&text));
println!("still here: {}", text);
}Returnera ägda strängar
När en funktion måste skapa ny text returnerar den en ägd String, så att anroparen tar över ägarskapet.
fn make_greeting(name: &str) -> String {
format!("Hello, {}!", name)
}
fn main() {
let g = make_greeting("Rust");
println!("{}", g);
}Välj rätt typ
Riktlinjer:
- Ska ni lagra ägd text? Använd
String. - Ska ni bara läsa eller skicka text? Acceptera
&str. - Ska ni skapa ny text i en funktion? Returnera
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));
}Varför skillnaden är viktig
Den här uppdelningen gör att Rust kan undvika onödiga kopior och garantera minnessäkerhet utan en skräpsamlare. Ni vet alltid vem som äger en viss textdel.
fn main() {
let owned = String::from("safe");
let borrowed = &owned[..];
println!("owner {} borrows {}", owned, borrowed);
}Snabbtest
Kom ihåg vad som händer när ni flyttar en String.
Sammanfattning
Ägarskap för String jämfört med &str:
Stringäger data på heapen och frigör den när värdet tas bort.&strlånar befintlig text och äger ingenting.- När en String flyttas blir originalet ogiltigt;
clonekopierar den. - Acceptera
&strför läsning och returneraStringför att skapa ny text.
fn shout(s: &str) -> String {
s.to_uppercase()
}
fn main() {
let name = String::from("rust");
let loud = shout(&name);
println!("{} -> {}", name, loud);
}
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
Vanliga frågor
Är lektionen ”String jämfört med &str” gratis?
Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Lär dig programmera i Rust, inklusive ”String jämfört med &str”, 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 ”String jämfört med &str”?
Ägarskap för text 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 1 av 4.
Hur lång tid tar lektionen ”String jämfört med &str”?
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
- String jämfört med &str
- Slices
- String-metoder
- UTF-8 och tecken