Rust Tutorial
Iniziare con Rust

Osservazioni

Versioni

Utilizzo avanzato di println!

println! (e suo fratello, print! ) fornisce un pratico meccanismo per la produzione e la stampa di testo che contiene i dati dinamici, simili al printf famiglia di funzioni che si trovano in molte altre lingue. Il primo argomento è una stringa di formato , che stabilisce come gli altri argomenti devono essere stampati come testo. La stringa di formato può contenere segnaposti (racchiusi in {} ) per specificare che si dovrebbe verificare una sostituzione:

// No substitution -- the simplest kind of format string
println!("Hello World");
// Output: Hello World

// The first {} is substituted with a textual representation of
// the first argument following the format string. The second {}
// is substituted with the second argument, and so on.
println!("{} {} {}", "Hello", true, 42);
// Output: Hello true 42

A questo punto, potresti chiederti: come ha fatto println! sapere di stampare il valore booleano true come la stringa "true"? {} è in realtà un'istruzione al formattatore che il valore dovrebbe essere convertito in testo usando il tratto Display . Questo tratto è implementato per la maggior parte dei tipi di ruggine primitivi (stringhe, numeri, booleani, ecc.) Ed è pensato per "output rivolto all'utente". Quindi, il numero 42 verrà stampato in decimale come 42, e non, per esempio, in binario, che è il modo in cui viene memorizzato internamente.

Come si stampano i tipi, quindi, che non implementano Display , gli esempi sono Slices ( [i32] ), i vettori ( Vec<i32> ) o le opzioni ( Option<&str> )? Non esiste una rappresentazione testuale chiara di questi utenti (cioè una che potresti inserire banalmente in una frase). Per facilitare la stampa di tali valori, Rust ha anche il tratto Debug e il segnaposto {:?} Corrispondente. Dalla documentazione: " Debug dovrebbe formattare l'output in un contesto di debugging del programmatore." Vediamo alcuni esempi:

println!("{:?}", vec!["a", "b", "c"]);
// Output: ["a", "b", "c"]

println!("{:?}", Some("fantastic"));
// Output: Some("fantastic")

println!("{:?}", "Hello");
// Output: "Hello"
// Notice the quotation marks around "Hello" that indicate
// that a string was printed.

Debug ha anche un meccanismo incorporato di stampa carina, che puoi abilitare usando il modificatore # dopo i due punti:

println!("{:#?}", vec![Some("Hello"), None, Some("World")]);
// Output: [
//    Some(
//        "Hello"
//    ),
//    None,
//    Some(
//        "World"
//    )
// ]

Le stringhe di formato consentono di esprimere sostituzioni piuttosto complesse :

// You can specify the position of arguments using numerical indexes.
println!("{1} {0}", "World", "Hello");
// Output: Hello World

// You can use named arguments with format
println!("{greeting} {who}!", greeting="Hello", who="World");
// Output: Hello World

// You can mix Debug and Display prints:
println!("{greeting} {1:?}, {0}", "and welcome", Some(42), greeting="Hello");
// Output: Hello Some(42), and welcome

println! e gli amici ti avvertiranno anche se stai provando a fare qualcosa che non funziona, piuttosto che a crash in fase di runtime:

// This does not compile, since we don't use the second argument.
println!("{}", "Hello World", "ignored");

// This does not compile, since we don't give the second argument.
println!("{} {}", "Hello");

// This does not compile, since Option type does not implement Display
println!("{}", Some(42));

Al loro centro, le macro di stampa Rust sono semplicemente wrapper in tutto il format! macro, che consente di costruire una stringa cucendo insieme rappresentazioni testuali di diversi valori di dati. Quindi, per tutti gli esempi sopra, puoi sostituire println! per il format! per memorizzare la stringa formattata invece di stamparla:

let x: String = format!("{} {}", "Hello", 42);
assert_eq!(x, "Hello 42");

Uscita della console senza macro

// use Write trait that contains write() function
use std::io::Write;

fn main() {
    std::io::stdout().write(b"Hello, world!\n").unwrap();
}

• Il tratto std::io::Write è progettato per oggetti che accettano flussi di byte. In questo caso, viene acquisito un handle per l'output standard con std::io::stdout() .

• Write::write() accetta una slice di byte ( &[u8] ), che viene creata con un letterale stringa di byte ( b"<string>" ). Write::write() restituisce un Result<usize, IoError> , che contiene il numero di byte scritti (in caso di successo) o un valore di errore (in caso di errore).

• La chiamata a Result::unwrap() indica che è previsto che la chiamata abbia esito positivo ( Result<usize, IoError> -> usize ) e il valore viene scartato.

Esempio minimo

Per scrivere il tradizionale programma Hello World in Rust, creare un file di testo chiamato hello.rs contenente il seguente codice sorgente:

fn main() {
    println!("Hello World!");
}

Definisce una nuova funzione chiamata main , che non accetta parametri e non restituisce dati. Questo è dove il tuo programma inizia l'esecuzione quando viene eseguito. Dentro, hai una println! , che è una macro che stampa il testo nella console.

Per generare un'applicazione binaria, richiamare il compilatore Rust passandogli il nome del file sorgente:

$ rustc hello.rs

L'eseguibile risultante avrà lo stesso nome del modulo sorgente principale, quindi per eseguire il programma su un sistema Linux o MacOS, eseguire:

$ ./hello
Hello World!

Su un sistema Windows, esegui:

C:\Rust> hello.exe
Hello World!

Iniziare

Installazione

Prima di poter fare qualsiasi cosa usando il linguaggio di programmazione di Rust, avrai bisogno di acquisirlo - sia per Windows che usando il tuo terminale su sistemi tipo Unix , dove $ simboleggia l'input nel terminale:

$ curl https://sh.rustup.rs -sSf | sh

Questo recupererà i file richiesti e configurerà per te la versione più recente di Rust, indipendentemente dal sistema in cui ti trovi. Per ulteriori informazioni, vedere la pagina del progetto .

Nota: alcune distribuzioni Linux (ad esempio Arch Linux ) forniscono rustup come pacchetto, che può essere installato al suo posto. E anche se molti sistemi simili a Unix forniscono rustc e cargo come pacchetti separati, si consiglia comunque di utilizzare la rustup quanto rende molto più facile la gestione di più canali di rilascio e la compilazione incrociata.

Rust Compiler

Ora possiamo verificare se Rust è stato effettivamente installato con successo sui nostri computer eseguendo il comando seguente nel nostro terminale, se su UNIX o sul prompt dei comandi, se su Windows:

$ rustc --version

Se questo comando ha successo, la versione del compilatore di Rust installata sui nostri computer verrà visualizzata sotto i nostri occhi.

Carico

Con Rust arriva Cargo , che è uno strumento di costruzione utilizzato per gestire i pacchetti ei progetti Rust . Per assicurarti che anche questo sia presente sul tuo computer, esegui il seguente comando all'interno della console-console facendo riferimento al terminale o al prompt dei comandi a seconda del sistema in cui ti trovi:

$ cargo --version

Proprio come il comando equivalente per il compilatore Rust , questo restituirà e mostrerà la versione corrente di Cargo .

Per creare il tuo primo progetto Cargo, puoi andare a Cargo .

In alternativa, è possibile compilare i programmi direttamente usando rustc come mostrato nell'esempio Minimo .