`array ([T; N])` în Rust

Un șir de lungime fixă, cunoscută la compilare, cu elemente de același tip, păstrat direct pe stivă.

Sintaxă

let a: [Tip; N] = [v1, v2, ..., vN];
let zero = [0; 5];           // 5 elemente egale cu 0
a[i]                         // accesul după indice (de la 0)
a.len()

Ce face `array ([T; N])`

Un array are tipul [T; N]: N elemente de tipul T. Lungimea face parte din tip, deci [i32; 3] și [i32; 4] sunt tipuri diferite și un array nu poate crește. Când ai nevoie de o listă care crește, folosește Vec.

[valoare; N] creează un array cu N copii ale aceleiași valori. Indicii încep de la 0. Fiecare acces a[i] este verificat: un indice în afara array-ului oprește programul cu panică, nu citește memorie străină ca în C.

Un array se poate parcurge cu for x in a (după valoare) sau for x in &a (prin referință) și are toate metodele unui slice: len, contains, iter, sort.

Exemple

Exemplul 1: Creare, acces și parcurgere

zile are 7 elemente, deci tipul lui este [&str; 7]. [0; 7] creează un array de 7 zerouri care apoi este completat.

fn main() {
    let zile = ["Lu", "Ma", "Mi", "Jo", "Vi", "Sâ", "Du"];
    let mut vanzari = [0; 7];
    vanzari[0] = 12;
    vanzari[4] = 30;
    vanzari[5] = 41;

    println!("Prima zi: {}, ultima: {}", zile[0], zile[zile.len() - 1]);
    for i in 0..zile.len() {
        if vanzari[i] > 0 {
            println!("{}: {} produse", zile[i], vanzari[i]);
        }
    }
    println!("Total: {}", vanzari.iter().sum::<i32>());
}

Rezultat

Prima zi: Lu, ultima: Du
Lu: 12 produse
Vi: 30 produse
Sâ: 41 produse
Total: 83

Exemplul 2: Array bidimensional

Un array de array-uri: 3 rânduri a câte 3 elemente. Este folosit aici pentru o tablă de X și O.

fn main() {
    let mut tabla = [['.'; 3]; 3];
    tabla[0][0] = 'X';
    tabla[1][1] = 'O';
    tabla[2][2] = 'X';
    for rand in &tabla {
        let text: String = rand.iter().collect();
        println!("{text}");
    }
}

Rezultat

X..
.O.
..X

Exemplul 3: Indice în afara array-ului

Indicele 7 nu există într-un array cu 7 elemente (indicii merg de la 0 la 6). Rust verifică accesul și oprește programul cu un mesaj clar.

fn vanzari_in_ziua(vanzari: [i32; 7], zi: usize) -> i32 {
    vanzari[zi]
}

fn main() {
    let vanzari = [12, 0, 5, 0, 30, 41, 8];
    println!("Ziua 6: {}", vanzari_in_ziua(vanzari, 6));
    println!("Ziua 7: {}", vanzari_in_ziua(vanzari, 7));
}

Rezultat (programul se oprește cu panică)

Ziua 6: 8

thread 'main' (14470534) panicked at main.rs:2:5:
index out of bounds: the len is 7 but the index is 7
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

Greșeli frecvente

Încerci să adaugi elemente (a.push(5)). Un array are lungime fixă; folosește Vec.
Folosești o variabilă pentru lungime: let n = 5; let a = [0; n]; nu se compilează. Lungimea trebuie să fie o constantă (const N: usize = 5;); pentru lungimi aflate la rulare folosește vec![0; n].
Folosești a[i] când i poate fi în afara array-ului. Metoda a.get(i) returnează Option (None în loc de panică).

Comenzi înrudite

slice-uri (&[T] și &str): O „fereastră” spre o parte dintr-un array, Vec sau text: o referință care știe de unde începe și câte elemente are, fără să copieze nimic.
tuple (tupluri): Grupează un număr fix de valori, de tipuri diferite, într-o singură valoare. Elementele se citesc cu .0, .1 sau prin desfacere.
for … in: Parcurge pe rând fiecare element al unui interval, al unei colecții sau al unui iterator.
vec!: Creează un Vec cu elementele date, sau cu n copii ale aceleiași valori, într-o singură expresie.

Ce face array ([T; N])