Output in Rust

Hai già usato println! parecchie volte. Questa pagina presenta le altre macro di stampa che incontrerai e quando usare ciascuna.

println! e print!

println! stampa del testo e aggiunge un a capo alla fine. print! fa la stessa cosa ma non aggiunge l’a capo:

fn main() {
    print!("Ciao, ");
    print!("mondo");
    println!("!");
}

Output:

Ciao, mondo!

▶ Provalo tu

Nota che tutte e tre le chiamate hanno stampato sulla stessa riga: solo println! va a capo. In pratica userai println! quasi sempre; print! serve soprattutto quando costruisci una riga un pezzo alla volta.

Segnaposto: {} e variabili con nome

Hai visto {} usato come segnaposto. Puoi riempirlo passando un valore dopo la stringa, oppure mettendo il nome della variabile direttamente dentro le graffe:

fn main() {
    let name = "Ferris";
    let age = 10;

    println!("{} ha {} anni", name, age); // posizionale
    println!("{name} ha {age} anni");     // in linea (stesso risultato)
}

Output:

Ferris ha 10 anni
Ferris ha 10 anni

▶ Provalo tu

Le due righe stampano la stessa cosa. Lo stile in linea ({name}) è un po’ più recente e di solito più leggibile, quindi preferiscilo quando puoi.

format!: costruire una stringa invece di stamparla

A volte vuoi il testo formattato come String invece di stamparlo subito, per esempio per salvarlo o passarlo a un’altra funzione. A questo serve format!. Funziona esattamente come println!, ma restituisce una String invece di stampare:

fn main() {
    let name = "Ferris";
    let message = format!("Ciao, {name}!");
    println!("{message}");
}

Output:

Ciao, Ferris!

▶ Provalo tu

Stampa di debug con {:?}

Il semplice {} funziona solo con valori che sanno mostrarsi come testo: numeri, stringhe, booleani. Con valori più complessi come tuple o struct, {} non compila. Usa invece {:?} (il formato «debug»):

fn main() {
    let point = (3, 7);
    println!("{:?}", point);
}

Output:

(3, 7)

▶ Provalo tu

Per un’impaginazione più gradevole, su più righe, con valori più grandi usa {:#?} (pretty-print):

fn main() {
    let point = (3, 7);
    println!("{:#?}", point);
}

Output:

(
    3,
    7,
)

▶ Provalo tu

Nota

Se Rust ti dice che un tipo «doesn’t implement Display» (non implementa Display), è il segnale per provare {:?} al posto di {}. È uno degli errori più comuni dei principianti quando stampano qualcosa.

Formattare i numeri

Qualche trucco di formattazione che capita spesso:

fn main() {
    let pi = 3.14159;
    println!("{:.2}", pi);   // 2 cifre decimali -> 3.14
    println!("{:5}", 42);    // larghezza 5      -> "   42"
    println!("{:08.2}", pi); // riempi con zeri  -> 00003.14
}

Output:

3.14
   42
00003.14

▶ Provalo tu

Non devi impararli a memoria: ti basta sapere che esistono, per quando devi allineare dei numeri o arrotondare dei decimali.

Allineare il testo e stampare le graffe

La larghezza funziona anche con il testo, e puoi scegliere da che lato si appoggia il valore. Dopo i : metti < (sinistra), > (destra) o ^ (centro), poi la larghezza. Davanti puoi anche mettere un carattere di riempimento, come -:

fn main() {
    let coffee = 3.5;
    let bagel = 2.25;

    println!("{:-^20}", " MENU ");
    println!("{:<12}{:>8}", "Articolo", "Prezzo");
    println!("{:<12}{:>8.2}", "Caffè", coffee);
    println!("{:<12}{:>8.2}", "Cornetto", bagel);
    println!("{:<12}{:>8.2}", "Totale", coffee + bagel);
}

Output:

------- MENU -------
Articolo      Prezzo
Caffè           3.50
Cornetto        2.25
Totale          5.75

▶ Provalo tu

Leggiamo {:>8.2} pezzo per pezzo: > significa allineato a destra, 8 è la larghezza e .2 significa due cifre decimali. Allineare i numeri a destra mette in colonna i punti decimali, ed è per questo che scontrini e tabelle lo fanno. (Rust usa sempre il punto come separatore decimale, non la virgola.)

E se vuoi una vera { nell’output? Siccome le graffe significano «segnaposto», le raddoppi: {{ stampa { e }} stampa }.

fn main() {
    println!("Insieme: {{{}, {}}}", 1, 2);
}

Output:

Insieme: {1, 2}

▶ Provalo tu

Stampare gli errori

Esiste anche eprintln! (ed eprint!). Funziona esattamente come println!, ma scrive sull’output degli errori invece che su quello normale. I terminali mostrano entrambi, ma se qualcuno salva l’output del tuo programma in un file, i messaggi di errore restano fuori. Usalo per avvisi e messaggi di errore.

Pratica

1. Un cartellino del prezzo

Salva l’articolo "Quaderno" e il prezzo 2.5, poi stampa Quaderno costa 2.50 euro. Suggerimento: {:.2} arrotonda a due cifre decimali, e funziona anche in linea: {price:.2}.

Mostra la soluzione

fn main() {
    let item = "Quaderno";
    let price = 2.5;
    println!("{item} costa {price:.2} euro");
}

Output:

Quaderno costa 2.50 euro

▶ Provalo tu

2. Costruisci un’etichetta, poi stampala in due modi

Usa format! per costruire un’etichetta ferris-7 a partire dal nome "ferris" e dal numero 7. Stampala una volta con {} e una volta con {:?}, e trova la differenza. Suggerimento: format! accetta esattamente gli stessi segnaposto di println!.

Mostra la soluzione

fn main() {
    let name = "ferris";
    let id = 7;
    let label = format!("{name}-{id}");

    println!("{label}");
    println!("{label:?}");
}

Output:

ferris-7
"ferris-7"

▶ Provalo tu

La stampa di debug mostra il testo tra virgolette, così vedi esattamente dove inizia e dove finisce. È comodo quando un valore contiene spazi di troppo.

Riepilogo

• println! stampa con un a capo; print! no.
• {} e {name} sono segnaposto per valori che sanno mostrarsi con Display.
• format! funziona come println! ma restituisce una String invece di stampare.
• {:?} (e {:#?}) stampa i valori per il debug, compresi quelli che {} non sa gestire.
• {:.2} arrotonda i decimali; <, > e ^ con una larghezza allineano il testo; {{ e }} stampano graffe vere.

Verifica veloce

Verifica veloce

1. Qual è la differenza tra println! e print!?

println! aggiunge un a capo alla fine, print! no print! aggiunge un a capo alla fine, println! no Non c'è nessuna differenza

2. Perché useresti {:?} invece di {} per stampare una tupla?

{:?} è più veloce Le tuple non implementano Display, quindi {} non compila {} funziona solo dentro print!, non in println!

Punteggio: 0 / 2

Per approfondire

• std::fmt — documentazione della libreria standard (in inglese): l’elenco completo delle opzioni di formattazione, compresi larghezza, riempimento, allineamento e precisione.
• Formatted print — Rust by Example (in inglese): esempi eseguibili di argomenti posizionali e con nome, riempimento e allineamento.
• Debug — Rust by Example (in inglese): come funzionano {:?} e {:#?} e come li ottengono i tuoi tipi.
• println! — documentazione della libreria standard (in inglese): il riferimento ufficiale di println!, con link a print! ed eprintln!.
• format! — documentazione della libreria standard (in inglese): costruire una String con le stesse regole di formattazione.