SE VUOI PRENDERE LA CERTIFICAZIONE PER QUESTO CORSO CLICCA QUI

Programmazione di un Gioco di Indovinelli

Saltiamo subito in Rust lavorando insieme su un progetto pratico! Questo capitolo ti introduce a alcuni concetti comuni di Rust mostrandoti come utilizzarli in un programma reale. Imparerai su let, match, metodi, funzioni associate, librerie esterne e altro ancora! Nei capitoli successivi, esploreremo queste idee in dettaglio. In questo capitolo, ti eserciterai solo sui fondamenti.

Implementeremo un classico problema di programmazione per principianti: un gioco di indovinelli. Ecco come funziona: il programma genererà un numero intero casuale compreso tra 1 e 100. Poi chiederà al giocatore di inserire un indovinello. Dopo che un indovinello è stato inserito, il programma indicherà se l’indovinello è troppo basso o troppo alto. Se l’indovinello è corretto, il gioco stamperà un messaggio di congratulazioni ed uscirà.

Impostare un Nuovo Progetto

Per configurare un nuovo progetto, vai alla directory dei progetti che hai creato nel Capitolo 1 e crea un nuovo progetto utilizzando Cargo, in questo modo:

bash

$ cargo new guessing_game
$ cd guessing_game


Il primo comando, cargo new, prende il nome del progetto (guessing_game) come primo argomento. Il secondo comando cambia nella directory del nuovo progetto.

Guarda il file Cargo.toml generato:

toml

[package]
name = "guessing_game"
version = "0.1.0"
edition = "2021" # Vedi altre chiavi e le loro definizioni su https://doc.rust-lang.org/cargo/reference/manifest.html

[dependencies]


Come hai visto nel Capitolo 1, cargo new genera un programma “Ciao, mondo!” per te. Dai un’occhiata al file src/main.rs:

rust

fn main() {
println!("Hello, world!");
}


Ora compiliamo questo programma “Hello, world!” ed eseguiamolo nello stesso passaggio usando il comando cargo run:

bash

$ cargo run
Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
Finished dev [unoptimized + debuginfo] target(s) in 1.50s
Running `target/debug/guessing_game`
Hello, world!


Il comando run è utile quando è necessario iterare rapidamente su un progetto, come faremo in questo gioco, testando rapidamente ogni iterazione prima di passare alla successiva.

Riapri il file src/main.rs. Scriverai tutto il codice in questo file.

Elaborazione di un Indovinello

La prima parte del programma del gioco di indovinelli chiederà un input all’utente, elaborerà quell’input e verificherà che l’input sia nella forma attesa. Per iniziare, permetteremo al giocatore di inserire un indovinello. Inserisci il codice nel Listato 2-1 in src/main.rs.

rust

use std::io; fn main() {
println!("Indovina il numero!"); println!("Inserisci il tuo indovinello."); let mut guess = String::new(); io::stdin()
.read_line(&mut guess)
.expect("Errore durante la lettura della riga");

println!("Hai indovinato: {}", guess);
}


Questo codice contiene molte informazioni, quindi andiamo riga per riga. Per ottenere l’input dell’utente e quindi stampare il risultato come output, dobbiamo portare nella portata la libreria di input/output io dalla libreria standard, nota come std:

rust

use std::io;


Per impostazione predefinita, Rust ha un insieme di elementi definiti nella libreria standard che porta nella portata di ogni programma. Questo insieme si chiama prelude, e puoi vedere tutto ciò che contiene nella documentazione della libreria standard.

Se un tipo che vuoi utilizzare non è nel preludio, devi portare quel tipo nella portata esplicitamente con una dichiarazione use. Utilizzando la libreria std::io ti fornisce una serie di funzionalità utili, incluso la possibilità di accettare l’input dell’utente.

Come hai visto nel Capitolo 1, la funzione main è il punto di ingresso nel programma:

rust

fn main() {


La sintassi fn dichiara una nuova funzione; le parentesi (), indicano che non ci sono parametri; e la parentesi graffa, {, inizia il corpo della funzione.

Come hai imparato anche nel Capitolo 1, println! è una macro che stampa una stringa sullo schermo:

rust

println!("Indovina il numero!");

println!("Inserisci il tuo indovinello.");


Questo codice sta stampando un prompt che indica qual è il gioco e richiede un input dall’utente.

Memorizzazione di Valori con Variabili

Successivamente, creeremo una variabile per memorizzare l’input dell’utente, in questo modo:

rust

let mut guess = String::new();


Ora il programma sta diventando interessante! C’è molto da fare in questa breve riga. Utilizziamo la dichiarazione let per creare la variabile. Ecco un altro esempio:

rust

let mele = 5;


Questa riga crea una nuova variabile chiamata mele e la lega al valore 5. In Rust, le variabili sono immutabili per impostazione predefinita, il che significa che una volta che abbiamo dato alla variabile un valore, il valore non cambierà. Discuteremo di questo concetto in dettaglio nella sezione “Variabili e Mutabilità” nel Capitolo 3. Per rendere una variabile mutabile, aggiungiamo mut prima del nome della variabile:

rust

let mele = 5; // immutabile
let mut banane = 5; // mutabile


Tornando al programma del gioco di indovinelli, ora sai che let mut guess introdurrà una variabile mutabile chiamata guess. Il segno uguale (=) indica a Rust che vogliamo legare qualcosa alla variabile ora. A destra del segno uguale c’è il valore a cui guess è legato, che è il risultato della chiamata a String::new, una funzione che restituisce una nuova istanza di una String. String è un tipo di stringa fornito dalla libreria standard che è un pezzo di testo UTF-8 espandibile.

La sintassi :: nella linea ::new indica che new è una funzione associata al tipo String. Una funzione associata è una funzione implementata su un tipo, in questo caso String. Questa nuova funzione crea una nuova stringa vuota. Troverai una nuova funzione su molti tipi perché è un nome comune per una funzione che crea un nuovo valore di qualche tipo.

In sintesi, la linea let mut guess = String::new(); ha creato una variabile mutabile attualmente legata a una nuova istanza vuota di una String. Whew!

Ricezione dell’Input dell’Utente

Ricorda che abbiamo incluso la funzionalità di input/output dalla libreria standard con use std::io; sulla prima riga del programma. Ora chiameremo la funzione stdin dal modulo io, che ci permetterà di gestire l’input dell’utente:

rust

io::stdin()
.read_line(&mut guess)


Se non avessimo importato la libreria io con use std::io; all’inizio del programma, avremmo comunque potuto utilizzare la funzione scrivendo questa chiamata di funzione come std::io::stdin. La funzione stdin restituisce un’istanza di std::io::Stdin, che è un tipo che rappresenta un manico per l’input standard del tuo terminale.

Successivamente, la riga .read_line(&mut guess) chiama il metodo read_line sul manico di input standard per ottenere l’input dall’utente. Stiamo anche passando &mut guess come argomento a read_line per dirgli in quale stringa memorizzare l’input dell’utente. Il lavoro completo di read_line è prendere ciò che l’utente digita nell’input standard e aggiungerlo in una stringa (senza sovrascrivere il suo contenuto), quindi passiamo quella stringa come argomento. La stringa dell’argomento deve essere mutabile in modo che il metodo possa cambiare il contenuto della stringa.

Il & indica che questo argomento è un riferimento, che ti offre un modo per consentire a più parti del tuo codice di accedere ad un pezzo di dati senza dover copiare quel dato in memoria più volte. I riferimenti sono una caratteristica complessa, e uno dei principali vantaggi di Rust è quanto sia sicuro ed facile utilizzare i riferimenti. Non è necessario conoscere molti di quei dettagli per completare questo programma. Per ora, tutto ciò che devi sapere è che, come le variabili, i riferimenti sono immutabili per impostazione predefinita. Pertanto, è necessario scrivere &mut guess anziché &guess per renderlo mutabile. (Il Capitolo 4 spiegherà i riferimenti più approfonditamente.)