0Pricing
Learn Rust Coding · Lezione

Tipi di dati primitivi e operatori

Esplori i tipi di dati primitivi integrati in Rust, come interi, numeri in virgola mobile, valori booleani e caratteri, insieme agli operatori più comuni.

Tipi di dati primitivi e operatori è una lezione Learn Rust Coding gratuita su CoddyKit. Questa è la lezione 2 di 3. 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 3 lezioni in totale.

Introduzione ai tipi di dati primitivi

Benvenuto a una lezione fondamentale su Rust! Oggi esploreremo i tipi di dati primitivi e gli operatori di base.

I tipi primitivi sono gli elementi fondamentali per memorizzare i dati. Rappresentano valori semplici come numeri, valori vero/falso o singoli caratteri.

Comprendere questi tipi è essenziale per scrivere codice Rust efficiente e corretto.

I tipi interi di Rust

Rust offre diversi tipi interi per soddisfare esigenze differenti. Si dividono in due categorie principali:

  • Interi con segno (prefisso i): possono memorizzare numeri positivi e negativi (ad esempio i8, i32, i64).
  • Interi senza segno (prefisso u): possono memorizzare solo numeri positivi o zero (ad esempio u8, u32, u64).

Il numero indica la quantità di bit utilizzati, ad esempio i32 è un intero con segno a 32 bit. isize e usize sono interi delle dimensioni di un puntatore e si adattano all'architettura del sistema (32 o 64 bit).

Dichiarare variabili intere

Vediamo come dichiarare e utilizzare i tipi interi in Rust. Noti che è possibile aggiungere esplicitamente un'annotazione del tipo oppure lasciare che Rust lo deduca.

Provi a eseguire questo esempio:

fn main() {
  let signed_val: i32 = -100;
  let unsigned_val: u32 = 250;
  let inferred_int = 500; // Rust infers i32 by default
  let big_unsigned: u64 = 1_000_000_000;

  println!("Signed: {}", signed_val);
  println!("Unsigned: {}", unsigned_val);
  println!("Inferred: {}", inferred_int);
  println!("Big Unsigned: {}", big_unsigned);
}

Numeri in virgola mobile

Per i numeri con cifre decimali, Rust offre i tipi in virgola mobile:

  • f32: numero in virgola mobile a precisione singola (32 bit).
  • f64: numero in virgola mobile a precisione doppia (64 bit). È il tipo in virgola mobile predefinito in Rust.

f64 è generalmente preferibile per la maggior parte delle applicazioni grazie alla maggiore precisione, a meno che non vi siano specifici vincoli di memoria o prestazioni.

Dichiarare variabili in virgola mobile

Ecco come dichiarare numeri in virgola mobile. Noti che Rust utilizza f64 per impostazione predefinita se non specifica un tipo.

Provi a eseguire questo esempio:

fn main() {
  let pi: f32 = 3.14159;
  let e = 2.718281828; // Inferred as f64
  let temperature: f64 = 98.6;

  println!("Pi (f32): {}", pi);
  println!("E (f64 inferred): {}", e);
  println!("Temperature (f64): {}", temperature);
}

Valori booleani e caratteri

Oltre ai numeri, Rust dispone di tipi per i valori logici e per i singoli caratteri:

  • bool: rappresenta un valore di verità, ovvero true o false.
  • char: rappresenta un singolo valore scalare Unicode. Ciò significa che un char può essere più di un semplice carattere ASCII: può essere qualsiasi lettera, emoji o simbolo.

Un char utilizza 4 byte di memoria, garantendo la possibilità di memorizzare qualsiasi carattere Unicode.

Valori bool e char in azione

Dichiariamo alcune variabili booleane e di tipo carattere. Noti l'uso delle virgolette singole per i valori char.

Provi a eseguire questo esempio:

fn main() {
  let is_rust_fun: bool = true;
  let has_errors = false; // Inferred as bool
  let first_letter: char = 'R';
  let emoji_char: char = '🚀';

  println!("Is Rust fun? {}", is_rust_fun);
  println!("Has errors? {}", has_errors);
  println!("First letter: {}", first_letter);
  println!("Emoji: {}", emoji_char);
}

Operatori aritmetici di base

Proprio come in matematica, Rust utilizza gli operatori per eseguire calcoli. Ecco i comuni operatori aritmetici:

  • +: addizione
  • -: sottrazione
  • *: moltiplicazione
  • /: divisione
  • %: resto (modulo)

Ricordi che la divisione tra interi (ad esempio 10 / 3) tronca la parte decimale, producendo un intero (3, non 3.33).

Utilizzare gli operatori aritmetici

Mettiamo in pratica questi operatori con alcuni numeri. Presti attenzione al comportamento della divisione tra interi!

Provi a eseguire questo esempio:

fn main() {
  let a = 15;
  let b = 4;

  println!("Addition: 15 + 4 = {}", a + b);
  println!("Subtraction: 15 - 4 = {}", a - b);
  println!("Multiplication: 15 * 4 = {}", a * b);
  println!("Integer Division: 15 / 4 = {}", a / b);
  println!("Remainder: 15 % 4 = {}", a % b);

  let x = 15.0;
  let y = 4.0;
  println!("Float Division: 15.0 / 4.0 = {}", x / y);
}

Quiz sui tipi primitivi

Verifichi la Sua comprensione dei tipi di dati primitivi e degli operatori di base di Rust.

Riepilogo: tipi primitivi e operatori

Ottimo lavoro! Ha imparato a conoscere i tipi di dati fondamentali di Rust:

  • Interi: i8, u8, i32, u32 ecc., per i numeri interi.
  • Numeri in virgola mobile: f32 e f64 per i numeri decimali.
  • Valori booleani: bool per true o false.
  • Caratteri: char per singoli valori Unicode.

Ha anche esplorato gli operatori aritmetici di base come +, -, *, / e %. Questi sono gli elementi fondamentali per creare logiche più complesse nei programmi.

Domande Frequenti

La lezione «Tipi di dati primitivi e operatori» è gratuita?

Sì — il testo completo di «Tipi di dati primitivi e operatori» è 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 3 lezioni in totale.

Cosa imparerò in «Tipi di dati primitivi e operatori»?

Esplori i tipi di dati primitivi integrati in Rust, come interi, numeri in virgola mobile, valori booleani e caratteri, insieme agli operatori più comuni. 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 3.

Quanto tempo richiede la lezione «Tipi di dati primitivi e operatori»?

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

  1. Variabili, mutabilità e shadowing
  2. Tipi di dati primitivi e operatori
  3. Funzioni e flusso di controllo
← Torna a Learn Rust Coding