Indicizzazione e iterazione
Acceda agli elementi e li percorra in un ciclo.
Indicizzazione e iterazione è una lezione Learn Rust Coding gratuita su CoddyKit. Questa è la lezione 2 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.
Leggere tramite indice
Ogni elemento di un vettore ha una posizione numerica chiamata indice. Gli indici iniziano da 0, quindi il primo elemento ha indice 0.
Leggete un elemento usando le parentesi quadre, come in v[0] per il primo valore.
fn main() {
let v = vec![100, 200, 300];
println!("first = {}", v[0]);
println!("third = {}", v[2]);
}Panico oltre i limiti
Accedere a un indice oltre la fine di un vettore provoca un panic e interrompe il programma. Per un vettore di lunghezza 3, gli unici indici validi sono 0, 1 e 2.
Richiedere qui v[5] causerebbe un arresto anomalo, quindi assicuratevi sempre che l'indice rientri nell'intervallo.
Accesso sicuro con get
Il metodo get restituisce un Option invece di provocare un panic. Ottenete Some(value) se l'indice esiste, oppure None se è fuori intervallo.
Questo consente di gestire con eleganza l'assenza di un elemento.
fn main() {
let v = vec![1, 2, 3];
match v.get(5) {
Some(x) => println!("got {}", x),
None => println!("no such index"),
}
}Quanti elementi ci sono
Il metodo len restituisce il numero di elementi. L'ultimo indice valido è sempre len - 1.
Conoscere la lunghezza vi aiuta a scorrere il vettore in sicurezza o a verificare i limiti prima di usare un indice.
fn main() {
let v = vec![5, 6, 7, 8];
println!("length = {}", v.len());
println!("last = {}", v[v.len() - 1]);
}Scorrere i valori
Il modo più chiaro per visitare ogni elemento consiste nell'usare un ciclo for su un riferimento al vettore. Usare &v prende in prestito il vettore, che rimane quindi utilizzabile in seguito.
A ogni iterazione n viene associato a un riferimento a un elemento.
fn main() {
let v = vec![2, 4, 6];
for n in &v {
println!("value: {}", n);
}
}Scorrere con l'indice
Quando vi serve anche la posizione, chiamate iter().enumerate(). A ogni passaggio restituisce coppie (index, value).
È perfetto per produrre un output numerato o applicare regole che dipendono dalla posizione.
fn main() {
let v = vec!["a", "b", "c"];
for (i, item) in v.iter().enumerate() {
println!("{}: {}", i, item);
}
}Modificare ogni elemento
Per modificare i valori direttamente, scorrete &mut v e il vettore deve essere mut. Ogni n è un riferimento mutabile, quindi per assegnargli un valore dovete dereferenziarlo con *.
Qui ogni elemento viene raddoppiato.
fn main() {
let mut v = vec![1, 2, 3];
for n in &mut v {
*n *= 2;
}
println!("{:?}", v);
}Sommare un vettore
Gli iteratori semplificano i calcoli. Il metodo iter().sum() somma tutti gli elementi.
Rust deve conoscere il tipo del risultato, quindi annotiamo il totale come i32.
fn main() {
let v = vec![10, 20, 30];
let total: i32 = v.iter().sum();
println!("sum = {}", total);
}Primo e ultimo elemento
I metodi first() e last() restituiscono riferimenti Option agli elementi iniziale e finale del vettore. Restituiscono None quando il vettore è vuoto.
Usarli evita calcoli manuali sugli indici e arresti anomali dovuti a indici fuori intervallo.
fn main() {
let v = vec![7, 8, 9];
println!("{:?}", v.first());
println!("{:?}", v.last());
}Cercare con contains
Per verificare se un valore è presente, usate contains. Il metodo accetta un riferimento al valore e restituisce un bool.
Scorre il vettore ed è un modo rapido per verificare l'appartenenza.
fn main() {
let v = vec![3, 6, 9];
println!("has 6? {}", v.contains(&6));
println!("has 5? {}", v.contains(&5));
}Creare una slice di un intervallo
Una slice prende in prestito una parte del vettore usando un intervallo, come &v[1..3]. L'inizio è incluso e la fine è esclusa.
Le slice consentono di lavorare con una finestra di elementi senza copiarli.
fn main() {
let v = vec![10, 20, 30, 40];
let middle = &v[1..3];
println!("{:?}", middle);
}Verifica rapida
Verificate la vostra comprensione degli indici e degli iteratori.
Riepilogo
Avete letto gli elementi tramite indice, vi avete acceduto in sicurezza con get e avete usato i cicli con for, enumerate e &mut.
Avete anche usato sum, first, last, contains e le slice. Ora imparerete a espandere e ridurre i vettori.
Domande Frequenti
La lezione «Indicizzazione e iterazione» è gratuita?
Sì — il testo completo di «Indicizzazione e iterazione» è 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 «Indicizzazione e iterazione»?
Acceda agli elementi e li percorra in un ciclo. 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 2 di 4.
Quanto tempo richiede la lezione «Indicizzazione e iterazione»?
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
- Creare e riempire vettori
- Indicizzazione e iterazione
- Aumentare e ridurre le dimensioni
- Vettori di struct