Referencer og borrowing forklaret
Lær om referencer og borrowing, som gør det muligt for flere dele af Deres kode at tilgå data uden at overtage ejerskabet – på en sikker måde.
Referencer og borrowing forklaret er en gratis Lær at programmere i Rust-lektion på CoddyKit. Dette er lektion 2 af 3. 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 3 lektioner i alt.
Hvad er referencer?
I Rust ejer variabler deres data. Men hvad nu, hvis du vil lade andre dele af din kode se på eller endda ændre disse data uden at overtage ejerskabet?
Det er her, referencer kommer ind i billedet! En reference er som en pointer til en værdi, men med strenge regler, der håndhæves af Rust-kompileren.
Tænk på det som at se på noget gennem et vindue i stedet for selv at eje det.
Din første reference
Vi opretter en reference ved hjælp af operatoren &. Den opretter en pointer til en værdi, som ikke overtager ejerskabet. Lad os se den i praksis:
fn print_length(s: &String) {
println!("The length is: {}", s.len());
}
fn main() {
let message = String::from("Hello, CoddyKit!");
print_length(&message); // Pass a reference
println!("Original message still here: {}", message);
}Forstå lån
Når du opretter en reference til en værdi, låner du værdien. Ejeren ejer den stadig, men du får midlertidig adgang.
- Lån uden at give væk: Du kan bruge de lånte data.
- Ingen overførsel af ejerskab: Den oprindelige variabel ejer stadig dataene og dropper dem, når den forlader sit scope.
- Sikkerhed først: Rusts låneregler forhindrer almindelige programmeringsfejl som datakapløb.
Uforanderlige lån: Adgang til læsning
Som standard er referencer i Rust uforanderlige. Det betyder, at du kan læse de data, de peger på, men ikke ændre dem.
Det er en central sikkerhedsfunktion! Hvis flere dele af din kode har skrivebeskyttet adgang, kan de ikke ved et uheld påvirke hinandens data.
Uforanderligt lån i praksis
Her modtager funktionen calculate_sum en uforanderlig reference til en vektor. Den kan læse elementerne, men ikke tilføje eller fjerne dem.
fn calculate_sum(numbers: &Vec<i32>) -> i32 {
let mut total = 0;
for num in numbers {
total += num;
}
total
}
fn main() {
let my_numbers = vec![10, 20, 30, 40];
let sum = calculate_sum(&my_numbers); // Immutable borrow
println!("The sum is: {}", sum);
println!("Original vector: {:?}", my_numbers);
}Mutable lån: Ændring af data
Nogle gange har du brug for at ændre data, som du har lånt. Til det bruger du en mutabel reference, der angives med &mut.
Mutable referencer har en vigtig regel: Du må kun have én mutabel reference til et bestemt stykke data ad gangen. Det forhindrer datakapløb og sikrer sikkerheden.
Ændring af data med &mut
Funktionen add_suffix tager en mutabel reference til en String. Den kan ændre den oprindelige String direkte.
fn add_suffix(text: &mut String) {
text.push_str(" (modified)");
}
fn main() {
let mut my_string = String::from("Original text");
add_suffix(&mut my_string); // Mutable borrow
println!("Modified string: {}", my_string);
}Lånets gyldne regler
Rusts compiler håndhæver disse regler på kompileringstidspunktet for at garantere sikker hukommelsesbrug:
- Du må have én mutabel reference til et stykke data ad gangen.
- ELLER du må have et vilkårligt antal immutabele referencer ad gangen.
- Du må ikke have en mutabel reference, mens der findes aktive immutabele referencer.
- Referencer skal altid være gyldige (de må ikke have længere levetid end de data, de peger på).
Disse regler forhindrer datakapløb og sikrer, at dine programmer er sikre og forudsigelige.
Konfliktende lån
Denne kode forsøger at oprette både en immutabel og en mutabel reference til my_value på samme tid, hvilket overtræder Rusts regler for lån. Den kan IKKE kompileres.
Prøv at køre den, og se compilerfejlen!
fn main() {
let mut my_value = 100;
let r1 = &my_value; // Immutable reference
let r2 = &mut my_value; // Mutable reference (problem here!)
println!("r1: {}", r1);
// println!("r2: {}", r2); // This line would also cause an error if uncommented
}Test din forståelse
Se på følgende Rust-kodestykke:
fn process_data(data: &mut Vec<i32>) {
data.push(4);
}
fn main() {
let mut numbers = vec![1, 2, 3];
let first_ref = &numbers[0]; // Line A
process_data(&mut numbers); // Line B
println!("First element: {}", first_ref); // Line C
}Hvilke linjer vil medføre en kompileringsfejl på grund af Rusts regler for lån?
Opsummering: Referencer og lån
Flot klaret! Du har lært det grundlæggende om referencer og lån i Rust:
- Referencer (
&) giver dig adgang til data uden at overtage ejerskabet. - Lån er handlingen at oprette en reference og låne adgangen til data.
- Immutabele referencer (
&) giver skrivebeskyttet adgang. - Mutable referencer (
&mut) giver læse- og skriveadgang. - Rusts strenge regler for lån (én mutabel ELLER mange immutabele) forhindrer datakapløb og sikrer sikker hukommelsesbrug på kompileringstidspunktet.
Disse begreber er afgørende for at skrive sikker og effektiv Rust-kode!
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
Ofte stillede spørgsmål
Er lektionen “Referencer og borrowing forklaret” gratis?
Ja — alle 3 lektioner i læringssporet Lær at programmere i Rust, inklusive “Referencer og borrowing forklaret”, 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 3 lektioner i alt.
Hvad lærer jeg i “Referencer og borrowing forklaret”?
Lær om referencer og borrowing, som gør det muligt for flere dele af Deres kode at tilgå data uden at overtage ejerskabet – på en sikker måde. 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 2 af 3.
Hvor lang tid tager lektionen “Referencer og borrowing forklaret”?
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
- Forstå Rusts ejerskabsmodel
- Referencer og borrowing forklaret
- Lifetimes til sikre referencer