Slice
Viste prese in prestito
Slice è 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.
Che cos'è una slice?
Una slice è una vista presa in prestito su una parte contigua di una collezione. Non possiede i dati — punta a dati già esistenti.
Le slice si scrivono usando un intervallo tra parentesi quadre.
fn main() {
let arr = [1, 2, 3, 4, 5];
let part = &arr[1..4];
println!("{:?}", part);
}Sintassi degli intervalli delle slice
Gli intervalli selezionano un indice iniziale e uno finale. L'estremo finale è esclusivo.
&v[1..4]— indici 1, 2, 3.&v[..3]— dall'inizio fino a 3.&v[2..]— da 2 fino alla fine.
fn main() {
let v = vec![10, 20, 30, 40];
println!("{:?}", &v[..2]);
println!("{:?}", &v[2..]);
}Slice di stringhe
Una slice di stringa &str è una vista su una parte di una String. Gli intervalli degli indici sono espressi in posizione dei byte.
fn main() {
let s = String::from("hello world");
let hello = &s[0..5];
let world = &s[6..11];
println!("{} {}", hello, world);
}Slice dell'intera collezione
Usi &v[..] per creare una slice dell'intera collezione. È così che un Vec viene preso in prestito come slice.
fn main() {
let v = vec![1, 2, 3];
let whole = &v[..];
println!("{:?}", whole);
}Le slice come parametri
Le funzioni che accettano &[T] accettano sia array sia vettori. Questo le rende flessibili.
fn sum(items: &[i32]) -> i32 {
let mut total = 0;
for x in items {
total += x;
}
total
}
fn main() {
let v = vec![1, 2, 3];
let a = [4, 5, 6];
println!("{} {}", sum(&v), sum(&a));
}Le slice prendono in prestito, non possiedono
Poiché una slice prende in prestito i dati, la collezione originale deve rimanere in vita mentre la slice viene utilizzata. Il compilatore lo verifica.
fn main() {
let v = vec![100, 200, 300];
let s = &v[0..2];
println!("slice {:?}, original {:?}", s, v);
}Lunghezza di una slice
Come le altre collezioni, le slice hanno un metodo len() che restituisce il numero di elementi coperti.
fn main() {
let v = vec![5, 6, 7, 8, 9];
let middle = &v[1..4];
println!("length {}", middle.len());
}first e last
Le slice forniscono first() e last(), che restituiscono degli Option per gestire in sicurezza le slice vuote.
fn main() {
let data = [10, 20, 30];
let s = &data[..];
println!("{:?} {:?}", s.first(), s.last());
}Iterare su una slice
Può iterare su una slice proprio come su qualsiasi collezione.
fn main() {
let v = vec![1, 2, 3, 4];
for x in &v[1..3] {
println!("{}", x);
}
}Una funzione per la prima parola
Un caso d'uso comune delle slice è restituire una slice del testo esistente, ad esempio la prima parola di una frase.
fn first_word(s: &str) -> &str {
let bytes = s.as_bytes();
for (i, &b) in bytes.iter().enumerate() {
if b == b' ' {
return &s[0..i];
}
}
s
}
fn main() {
println!("{}", first_word("hello there"));
}Perché le slice sono sicure
Le slice evitano di copiare i dati e impediscono al contempo i riferimenti pendenti. Il borrow checker garantisce che i dati sottostanti rimangano in vita più a lungo della slice.
fn main() {
let words = vec!["a", "b", "c", "d"];
let pair = &words[1..3];
println!("{:?}", pair);
}Verifica rapida
Ricordi che cosa rappresenta una slice.
Riepilogo
Le slice in Rust:
- Una vista presa in prestito:
&v[start..end], con estremo finale esclusivo. &strè una slice di stringa;&[T]è una slice di array o vettore.- I parametri di tipo slice accettano sia array sia vettori.
- Il borrow checker mantiene sicure le slice.
fn average(nums: &[i32]) -> i32 {
nums.iter().sum::<i32>() / nums.len() as i32
}
fn main() {
let v = vec![4, 8, 12];
println!("{}", average(&v[..]));
}Domande Frequenti
La lezione «Slice» è gratuita?
Sì — il testo completo di «Slice» è 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 «Slice»?
Viste prese in prestito 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 «Slice»?
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.