Impara Rust nel 2022

Se hai intenzione di esplorare Rust quest'anno, scarica il nostro cheat sheet gratuito su Rust, così avrai un rapido riferimento per le nozioni di base.

Rust è un linguaggio di programmazione relativamente nuovo ed è già popolare e conquista programmatori di tutti i settori. Tuttavia, è anche un linguaggio che si basa su tutto ciò che è venuto prima. Dopotutto, Rust non è stato creato in un giorno, quindi anche se ci sono concetti in Rust che sembrano molto diversi da ciò che potresti aver imparato da Python, Java, C++ e così via, hanno tutti un fondamento nella stessa CPU. e l'architettura NUMA con cui hai sempre interagito (che tu lo sappia o no), quindi alcune delle novità di Rust sembrano in qualche modo familiari.

Ora, non sono un programmatore di mestiere. Sono impaziente ma allo stesso tempo ossessivo. Se una lingua non mi aiuta a ottenere i risultati che desidero in tempi relativamente brevi, raramente mi trovo ispirato a usarla quando ho bisogno di fare qualcosa. Rust cerca di portare in equilibrio due cose contrastanti: la necessità del computer moderno di un codice sicuro e strutturato e il desiderio del programmatore moderno di fare meno lavoro ottenendo più successo.

Installa Rust

Il sito web ruggine-lang.org offre un'ottima documentazione sull'installazione di Rust, ma di solito è semplice come scaricare lo script sh.rustup.rs ed eseguirlo.

$ curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs

$ less sh.rustup.sh

$ sh ./sh.rustup.rs

Niente classi

Rust non ha classi e non utilizza la parola chiave class. Rust ha il tipo di dati struct, tuttavia, il suo scopo è quello di servire come una sorta di modello per una raccolta di dati. Quindi invece di creare una classe per rappresentare un oggetto virtuale, puoi usare una struttura:

struct Penguin {
    genus: String,
    species: String,
    extinct: bool,
    classified: u64,
}

Puoi usarlo in modo simile a come viene utilizzata una classe. Ad esempio, una volta definita una struttura Penguin, puoi crearne istanze e interagire con tale istanza:

struct Penguin {
    genus: String,
    species: String,
    extinct: bool,
    classified: u64,
}

fn main() {
    let p = Penguin { genus: "Pygoscelis".to_owned(),
         species: "R adeliæ".to_owned(), 
         extinct: false, 
         classified: 1841 };

    println!("Species: {}", p.species);    
    println!("Genus: {}", p.genus);
    println!("Classified in {}", p.classified);
    if p.extinct == true {
        println!("Sadly this penguin has been made extinct.");
    }
    
}

Utilizzando il tipo di dati impl insieme al tipo di dati struct, puoi implementare una struttura contenente funzioni e aggiungere ereditarietà e altre funzionalità simili alle classi.

Funzioni

Le funzioni in Rust sono molto simili alle funzioni di altri linguaggi. Ognuno rappresenta un insieme discreto di attività a cui puoi ricorrere quando necessario. La funzione primaria deve essere chiamata main.

Le funzioni vengono dichiarate utilizzando la parola chiave fn, seguita dal nome della funzione e da eventuali parametri accettati dalla funzione.

fn foo() {
  let n = 8;
  println!("Eight is written as {}", n);
}

Il passaggio delle informazioni da una funzione all'altra avviene tramite parametri. Ad esempio, ho già creato una classe Penguin e ho un'istanza di un pinguino come p, quindi passo gli attributi di p da una funzione all'altra richiede che io specifichi p come tipo Penguin accettato per la sua funzione di destinazione.

fn main() {
  let p = Penguin { genus: "Pygoscelis".to_owned(), 
    species: "R adeliæ".to_owned(), 
    extinct: false, classified: 1841 };
  printer(p);
}

fn printer(p: Penguin) {
  println!("Species: {}", p.species);    
  println!("Genus: {}", p.genus);
  println!("Classified in {}", p.classified);
  if p.extinct == true {
      println!("Sadly this penguin has been made extinct.");
  }
}

Variabili 

Rust crea variabili immutabili per impostazione predefinita. Ciò significa che una variabile creata non può essere modificata successivamente. Questo codice, per quanto umile possa essere, non può essere compilato:

fn main() {
 let n = 6;
 let n = 5;
 }

Tuttavia, puoi dichiarare una variabile mutabile con la parola chiave mut, quindi questo codice verrà compilato correttamente:

fn main() {
 let mut n = 6;
 println!("Value is {}", n);
 n = 5;
 println!("Value is {}", n);
}

Compilatore 

Il compilatore Rust, almeno in termini di messaggi di errore, è uno dei compilatori più simpatici disponibili. Quando sbagli qualcosa in Rust, il compilatore fa uno sforzo sincero per dirti cosa hai fatto di sbagliato. In realtà ho imparato molte sfumature di Rust (nella misura in cui comprendo qualsiasi sfumatura di Rust) semplicemente imparando dai messaggi di errore del compilatore. Anche quando un messaggio di errore è troppo oscuro per poterne apprendere direttamente, è quasi sempre sufficiente una ricerca su Internet per spiegarlo.

Il modo più semplice per avviare un programma Rust è utilizzare cargo, il sistema di gestione e creazione dei pacchetti Rust.

$ mkdir myproject
$ cd myproject
$ cargo init 

Ciò crea l'infrastruttura di base per un progetto, in particolare un file main.rs nella sottodirectory src. Apri questo file e incolla il codice di esempio che ho generato per questo articolo:

struct Penguin {
    genus: String,
    species: String,
    extinct: bool,
    classified: u64,
}

fn main() {
    let p = Penguin { genus: "Pygoscelis".to_owned(), species: "R adeliæ".to_owned(), extinct: false, classified: 1841 };
    printer(p);
    foo();
}

fn printer(p: Penguin) {
    println!("Species: {}", p.species);    
    println!("Genus: {}", p.genus);
    println!("Classified in {}", p.classified);
    if p.extinct == true {
        println!("Sadly this penguin has been made extinct.");
    }
}

fn foo() {
     let mut n = 6;
 println!("Value is {}", n);
 n = 8;
  println!("Eight is written as {}", n);
}

Per compilare, utilizza il comando cargo build:

$ cargo build

Per eseguire il tuo progetto, esegui il file binario nella sottodirectory target, oppure utilizza semplicemente cargo run: 

$ cargo run
Species: R adeliæ
Genus: Pygoscelis
Classified in 1841
Value is 6
Eight is written as 8

Casse

Gran parte della comodità di qualsiasi linguaggio deriva dalle sue librerie o moduli. In Rust, le librerie vengono distribuite e tracciate come "casse". Il sito web crates.io è un buon registro dei crate della comunità.

Per aggiungere un crate al tuo progetto Rust, elencali nel file Cargo.toml. Ad esempio, per installare una funzione di numero casuale, utilizzo il crate rand, con * che funge da carattere jolly per assicurarmi di ottenere la versione più recente in fase di compilazione:

[package]
name = "myproject"
version = "0.1.0"
authors = ["Seth <seth@opensource.com>"]
edition = "2022"

[dependencies]
rand = "*"

Per utilizzarlo nel codice Rust è necessaria un'istruzione use in alto:

use rand::Rng;

Alcuni codici di esempio che creano un seme casuale e quindi un intervallo casuale:

fn foo() {
    let mut rng = rand::thread_rng();
    let mut n = rng.gen_range(1..99);

    println!("Value is {}", n);
    n = rng.gen_range(1..99);
    println!("Value is {}", n);
}

Puoi utilizzare cargo run per eseguirlo, che rileva la modifica del codice e attiva una nuova build. Il processo di compilazione scarica il crate rand e tutti i crate da cui, a sua volta, dipende, compila il codice e quindi lo esegue:

$ cargo run
Updating crates.io index
Downloaded ppv-lite86 v0.2.16
Downloaded 1 crate (22.2 KB) in 1.40s
 Compiling libc v0.2.112
 Compiling cfg-if v1.0.0
 Compiling ppv-lite86 v0.2.16
 Compiling getrandom v0.2.3
 Compiling rand_core v0.6.3
 Compiling rand_chacha v0.3.1
 Compiling rand v0.8.4
 Compiling rustpenguin v0.1.0 (/home/sek/Demo/rustpenguin)
 Finished dev [unoptimized + debuginfo] target(s) in 13.97s
 Running `target/debug/rustpenguin`

Species: R adeliæ
Genus: Pygoscelis
Classified in 1841
Value is 70
Value is 35

Foglio informativo sulla ruggine

La ruggine è una lingua estremamente piacevole. Grazie alla sua integrazione con i registri online, al suo utile compilatore e alla sua sintassi quasi intuitiva, sembra adeguatamente moderno.

Non commettere errori, però, è anche un linguaggio complesso, con tipi di dati rigorosi, variabili con ambito forte e molti metodi integrati. Vale la pena dare un'occhiata a Rust e, se hai intenzione di esplorare Rust, dovresti scaricare il nostro cheat sheet gratuito, in modo da avere un rapido riferimento per le nozioni di base. Prima inizi, prima conoscerai Rust. E, naturalmente, dovresti esercitarti spesso per evitare di arrugginirti.