Tipi scalari
Interi, numeri in virgola mobile, bool e char
Tipi scalari è 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.
Cosa sono i tipi scalari?
Un tipo scalare rappresenta un singolo valore. Rust ha quattro tipi scalari principali:
- Interi
- Numeri in virgola mobile
- Valori booleani
- Caratteri
fn main() {
let i = 10; // integer
let f = 2.5; // float
let b = true; // bool
let c = 'R'; // char
println!("{} {} {} {}", i, f, b, c);
}Tipi interi
Gli interi sono disponibili nelle varianti con segno (i) e senza segno (u), con dimensioni fisse: i8, i16, i32, i64, i128 e gli equivalenti per u.
Il tipo intero predefinito è i32.
fn main() {
let small: i8 = -120;
let big: u64 = 18_000_000_000;
println!("{} {}", small, big);
}Con segno e senza segno
Gli interi con segno possono essere negativi; quelli senza segno no.
i8va da -128 a 127.u8va da 0 a 255.
Scelga un tipo senza segno quando un valore non può mai essere negativo, ad esempio per un conteggio.
fn main() {
let temperature: i32 = -15;
let people: u32 = 250;
println!("temp {} people {}", temperature, people);
}Valori letterali interi
È possibile scrivere gli interi in basi diverse e usare gli underscore per migliorarne la leggibilità.
- Decimale:
1_000_000 - Esadecimale:
0xff - Ottale:
0o77 - Binaria:
0b1010
fn main() {
let dec = 1_000;
let hex = 0xff;
let bin = 0b1010;
println!("{} {} {}", dec, hex, bin);
}Tipi in virgola mobile
Rust dispone di due tipi in virgola mobile: f32 e f64. Il valore predefinito è f64, perché offre una maggiore precisione.
I numeri in virgola mobile seguono lo standard IEEE-754.
fn main() {
let pi: f64 = 3.141592;
let e: f32 = 2.718;
println!("pi {} e {}", pi, e);
}Operazioni numeriche
Rust supporta i consueti operatori matematici: +, -, *, / e % (resto).
La divisione tra interi tronca il risultato verso zero.
fn main() {
let sum = 5 + 10;
let quotient = 7 / 2; // 3 (integer)
let remainder = 7 % 2; // 1
let float_div = 7.0 / 2.0; // 3.5
println!("{} {} {} {}", sum, quotient, remainder, float_div);
}Il tipo booleano
Il tipo bool ha esattamente due valori: true e false.
I valori booleani vengono prodotti dai confronti e usati nelle condizioni if.
fn main() {
let is_active = true;
let is_bigger = 10 > 3;
println!("{} {}", is_active, is_bigger);
}Il tipo carattere
Un char rappresenta un singolo valore scalare Unicode e viene scritto usando gli apici singoli.
Un char Rust occupa 4 byte e può contenere molto più dell'ASCII, incluse emoji e lettere accentate.
fn main() {
let letter = 'A';
let symbol = '@';
let heart = '\u{2764}';
println!("{} {} {}", letter, symbol, heart);
}char e String a confronto
Gli apici singoli creano un char; i doppi apici creano una string slice (&str).
'a'è un singolo carattere."a"è una stringa di un carattere.
fn main() {
let c = 'x';
let s = "x";
println!("char {} string {}", c, s);
}Conversione dei tipi con as
Rust non converte automaticamente i tipi numerici. Usi la parola chiave as per eseguire cast espliciti.
Faccia attenzione: convertire a un tipo più piccolo può causare una perdita di dati.
fn main() {
let x: i32 = 65;
let y: f64 = x as f64;
let c = x as u8 as char;
println!("{} {} {}", x, y, c);
}Combinare i tipi scalari
I programmi combinano continuamente i tipi scalari. Qui mescoliamo interi, numeri in virgola mobile e valori booleani per prendere una decisione.
fn main() {
let price: f64 = 19.99;
let quantity: u32 = 3;
let total = price * quantity as f64;
let is_expensive = total > 50.0;
println!("total {} expensive {}", total, is_expensive);
}Verifica rapida
Verifichi le Sue conoscenze dei valori letterali scalari di Rust.
Riepilogo
I quattro tipi scalari di Rust:
- Interi — con segno (i32) e senza segno (u32), di varie dimensioni.
- Numeri in virgola mobile — f32 e f64, con f64 come valore predefinito.
- bool — true o false.
- char — un singolo valore Unicode tra apici singoli.
Usi as per le conversioni numeriche esplicite.
fn main() {
let count: u32 = 42;
let ratio: f64 = count as f64 / 7.0;
let ok: bool = ratio > 5.0;
let grade: char = 'B';
println!("{} {} {} {}", count, ratio, ok, grade);
}Domande Frequenti
La lezione «Tipi scalari» è gratuita?
Sì — il testo completo di «Tipi scalari» è 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 «Tipi scalari»?
Interi, numeri in virgola mobile, bool e char 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 «Tipi scalari»?
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
- let e mutabilità
- Tipi scalari
- Tipi composti
- Shadowing