Learn Rust Coding · Lezione

String vs &str

Ownership del testo

String vs &str è una lezione Learn Rust Coding gratuita su CoddyKit. Questa è la lezione 1 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Learn Rust Coding, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Learn Rust Coding include 4 lezioni in totale.

Testo posseduto e preso in prestito

Rust distingue la proprietà del testo in due tipi:

String — possiede i propri dati nell'heap.
&str — prende in prestito una vista del testo che non possiede.

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

Dove risiedono i dati

Una String memorizza i propri byte nell'heap e può crescere. Un valore letterale stringa &str è incorporato nel binario del programma ed è fisso.

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

La proprietà implica responsabilità

Il proprietario di una String libera la memoria quando la stringa esce dall'ambito. Un &str non possiede nulla, quindi non libera mai alcuna memoria.

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

Prendere in prestito una String

Può prendere in prestito una String come &str utilizzando &. La String continua a possedere i dati; la slice si limita ad accedervi.

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

Spostare una String

Assegnare una String a un'altra variabile sposta la proprietà. L'originale non può più essere utilizzata.

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

Clonare per conservarle entrambe

Se ha bisogno di due stringhe possedute e indipendenti, utilizzi clone per copiare i dati.

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

Copiare un &str è economico

Un &str è semplicemente un puntatore e una lunghezza, quindi copiarlo non copia il testo sottostante. Implementa Copy.

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

Funzioni e ownership

Passare una String per valore la sposta nella funzione. Passare &str o &String prende solo in prestito il valore, lasciandolo utilizzabile dal chiamante.

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

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

Restituire stringhe possedute

Quando una funzione deve produrre nuovo testo, restituisce una String posseduta, in modo che il chiamante ne acquisisca la proprietà.

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

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

Scegliere il tipo giusto

Linee guida:

Deve memorizzare testo posseduto? Usi String.
Deve solo leggere o passare del testo? Accetti &str.
Deve creare nuovo testo in una funzione? Restituisca 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));
}

Perché la distinzione è importante

Questa distinzione permette a Rust di evitare copie non necessarie e garantisce la sicurezza della memoria senza un garbage collector. Saprà sempre chi possiede una porzione di testo.

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

Verifica rapida

Ricordi cosa accade quando si sposta una String.

Riepilogo

Ownership di String e &str:

String possiede i dati nell'heap e li libera quando viene eliminata.
&str prende in prestito testo esistente e non possiede nulla.
Spostare una String rende inutilizzabile l'originale; clone ne crea una copia.
Accetti &str per leggere e restituisca String per produrre nuovo testo.

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

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

Domande Frequenti

La lezione «String vs &str» è gratuita?

Sì — il testo completo di «String vs &str» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Learn Rust Coding, passa a CoddyKit PRO. Il corso Learn Rust Coding include 4 lezioni in totale.

Cosa imparerò in «String vs &str»?

Ownership del testo Eserciti Learn Rust Coding con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Learn Rust Coding?

Non è richiesta alcuna esperienza precedente. Learn Rust Coding su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 1 di 4.

Quanto tempo richiede la lezione «String vs &str»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Learn Rust Coding?

Sì. Ogni lezione Learn Rust Coding include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a Learn Rust Coding