as (conversii numerice) în Rust

valoare as TipNou
use cale::Nume as Alias;      // redenumire la import

Ce face as (conversii numerice)

Rust nu convertește automat între tipurile numerice, nici măcar din i32 în i64. as face conversia explicit: nota as f64, lungime as i32, 'A' as u32, true as u8.

Regulile sunt fixe și nu dau niciodată panică: din f64 în întreg partea zecimală se taie (spre zero), iar valorile prea mari se opresc la limita tipului (300.7 as u8 dă 255, NaN dă 0). Între întregi, biții în plus se pierd: 300 as u8 dă 44 (300 − 256), iar -1i32 as u32 dă 4294967295.

Pentru conversii în care pierderea ar fi o greșeală, folosește From/Into (doar conversiile sigure, de exemplu u8 → u32) sau TryFrom/try_into(), care returnează Err când valoarea nu încape. În use, as are alt rol: dă alt nume unui element importat.

Exemple

Exemplul 1: Conversii obișnuite

Media are nevoie de f64, deci atât suma, cât și numărul de note sunt convertite. as i32 taie zecimalele, nu rotunjește; pentru rotunjire folosește round() înainte.

fn main() {
    let note = [9, 8, 10, 7];
    let suma: i32 = note.iter().sum();
    let media = suma as f64 / note.len() as f64;
    println!("Media: {media}");
    println!("Tăiată: {}", media as i32);
    println!("Rotunjită: {}", media.round() as i32);
    println!("'A' are codul {}, iar 97 este '{}'", 'A' as u32, 97u8 as char);
    println!("true as u8 = {}", true as u8);
}

Rezultat

Media: 8.5
Tăiată: 8
Rotunjită: 9
'A' are codul 65, iar 97 este 'a'
true as u8 = 1

Exemplul 2: Unde as pierde informație

Niciuna dintre aceste conversii nu dă eroare, dar toate schimbă valoarea. De aceea as trebuie folosit doar când ești sigur că valoarea încape.

fn main() {
    let mare: i32 = 300;
    let negativ: i32 = -1;
    let cu_virgula: f64 = 300.7;
    println!("300 as u8   = {}", mare as u8);
    println!("-1 as u32   = {}", negativ as u32);
    println!("300.7 as u8 = {}", cu_virgula as u8);
    println!("-5.9 as i32 = {}", -5.9_f64 as i32);
    println!("NaN as i32  = {}", f64::NAN as i32);
}

Rezultat

300 as u8   = 44
-1 as u32   = 4294967295
300.7 as u8 = 255
-5.9 as i32 = -5
NaN as i32  = 0

Exemplul 3: Alternativa sigură: From și TryFrom

u32::from există doar pentru conversiile care nu pot pierde nimic. u8::try_from(300) returnează Err în loc să dea 44.

fn main() {
    let octet: u8 = 200;
    let mare = u32::from(octet);
    println!("u8 -> u32: {mare}");

    for valoare in [120, 300] {
        match u8::try_from(valoare) {
            Ok(v) => println!("{valoare} încape în u8: {v}"),
            Err(e) => println!("{valoare} nu încape în u8: {e}"),
        }
    }
}

Rezultat

u8 -> u32: 200
120 încape în u8: 120
300 nu încape în u8: number too large to fit in target type

Greșeli frecvente

• Folosești as pentru a converti un text în număr ("42" as i32). Nu se compilează; pentru text ai nevoie de "42".parse::<i32>().
• Aștepți rotunjire de la as: 2.9 as i32 dă 2. Apelează .round() înainte de conversie.
• Convertești lungimi sau indici negativi cu as usize: -1i32 as usize devine un număr uriaș, iar indexarea dă panică. Verifică semnul sau folosește usize::try_from.

Comenzi înrudite

• tipuri scalare (întregi, f64, bool, char): Tipurile de bază ale lui Rust: întregi cu și fără semn, numere cu virgulă, bool (true/false) și char (un caracter Unicode).
• shadowing (umbrirea variabilelor): Declari din nou o variabilă cu același nume: cea nouă o ascunde pe cea veche și poate avea chiar alt tip.
• use: Aduce în domeniu un nume dintr-un modul sau crate (std::collections::BTreeMap), ca să-l poți folosi fără calea completă.
• operatorul ?: Pus după un Result sau Option: dă valoarea dacă totul e bine, altfel returnează imediat eroarea (sau None) din funcția curentă.