Questi sono valori booleani comuni che possono essere veri o falsi.

carattere

Questo tipo è caratterizzato dalla larghezza di bit. La lunghezza massima supportata da Rust è 128 bit.

Un intero con segno di dimensione variabile (la dimensione dipende dalla dimensione del puntatore sottostante).

Intero senza segno di dimensione variabile (la dimensione dipende dalla dimensione del puntatore sottostante).

tipo a virgola mobile f32 bit

tipo a virgola mobile f64 bit

Una matrice di dimensioni fisse, T rappresenta il tipo di elemento, N rappresenta il numero di elementi ed è una costante non negativa in fase di compilazione.

Una vista con dimensioni dinamiche di una sequenza contigua, dove T rappresenta qualsiasi tipo.

Affettatura di stringhe, utilizzata principalmente come riferimento, ovvero &str

Le successioni finite, T e U possono essere di diverso tipo.

Una funzione che riceve un parametro di tipo i32 e restituisce un parametro di tipo i32. Anche le funzioni hanno un tipo.

fn aggiungi(a: u64, b: u64) -> u64 { un b } fn principale() { sia a: u64 = 17; sia b = 3; lascia risultato = aggiungi(a, b); println!("Risultato {}", risultato); }

fn principale() { sia raddoppiatore = |x|. lascia valore = 5; let due volte = duplicatore(valore); println!("{} raddoppiato è {}", valore, due volte); lascia grande_chiusura = |b, c| { sia z = b c; z * due volte }; lascia che qualche_numero = big_closure(1, 2); println!("Risultato della chiusura: {}", some_number); }

fn principale() { let domanda = "Come stai?"; let persona: String = "Bob".to_string(); let namaste = String::from("zd"); println!("{}! {} {}", namaste, domanda, persona); }

Nel codice precedente, il tipo di persona e namaste è String e il tipo di domanda è &str. Esistono molti modi per creare dati di tipo String. I dati di tipo stringa vengono allocati nell'heap. I dati di tipo &str sono solitamente un puntatore a una stringa esistente. Queste stringhe si trovano nello stack e nell'heap oppure possono essere stringhe nel segmento dati del codice oggetto compilato.

fn principale() { lascia che ruggine_is_awesome = vero; se la ruggine_è_fantastica { println!("Certamente"); } altro { println!("Beh, dovresti provare Rust!"); } }

fn principale() { lascia risultato = se 1 == 2 { "Aspetta cosa?" } altro { "La ruggine ha un senso" }; println!("Sai una cosa? {}.", risultato); }

Quando il valore da assegnare viene restituito dall'espressione if else, dobbiamo utilizzare un punto e virgola come segno di fine. Ad esempio, se è un'espressione, allora let è un'istruzione che prevede la presenza di un punto e virgola alla fine.

fn stato_req() -> u32 { 200 } fn principale() { lascia stato = req_status(); stato della corrispondenza { 200 => println!("Riuscito"), 404 => println!("Non trovato"), altro => { println!("Richiesta fallita con il codice: {}", other); } } }

fn principale() { sia mut x = 1024; ciclo continuo { se x < 0 { rottura; } println!("{} altre corse da fare", x); x-= 1; } }

fn stupido_sub(a: i32, b: i32) -> i32 { lascia che mut risultato = 0; 'incremento: ciclo { se risultato == a { sia mut dec = b; 'decremento: ciclo { ifdec==0{ break 'incremento; } altro { risultato -= 1; dicembre -= 1; } } } altro { risultato = 1; } } risultato } fn principale() { sia a = 10; sia b = 4; lascia risultato = silly_sub(a, b); println!("{} meno {} fa {}", a, b, risultato); }

fn principale() { print!("Intervallo normale: "); per i in 0..10 { stampa!("{},", i); } stampaln!(); print!("Intervallo compreso: "); per i in 0..=10 { stampa!("(),", i); } }

In Rust esistono tre forme di dichiarazione di struttura. La più semplice di queste è la unit struct, che viene dichiarata utilizzando la parola chiave struct, seguita dal suo nome e terminando con un punto e virgola.

La seconda forma di struttura è la struttura tupla, a cui sono associati dati. A ciascuno di questi campi non viene assegnato un nome, ma viene fatto riferimento in base alla posizione nella definizione.

Le strutture di tupla sono ideali quando si modellano dati con meno di 5 attributi. Qualsiasi scelta diversa da questa ostacolerà la leggibilità e il ragionamento del codice. Per i tipi di dati con più di 3 campi, costruire strutture utilizzando un linguaggio simile al C. Questa è la terza forma e la forma più comunemente utilizzata.

Le enumerazioni sono un buon modo per farlo quando è necessario modellare diversi tipi di cose. Viene creato utilizzando la parola chiave enum, seguita dal nome dell'enumerazione e da una coppia di parentesi graffe. All'interno delle parentesi graffe possiamo scrivere tutti i tipi possibili, cioè le varianti. Queste varianti possono essere definite con o senza dati e i dati contenuti possono essere qualsiasi tipo far, struttura, struttura tupla o anche un tipo di enumerazione.

Possiamo aggiungere un comportamento a una struttura definita utilizzando due meccanismi: funzioni di tipo costruttore e metodi getter e setter.

Le enumerazioni sono ampiamente utilizzate nelle macchine a stati e, se utilizzate con espressioni di corrispondenza, possono rendere il codice di transizione dello stato molto conciso. Possono essere utilizzati anche per la modellazione di tipi di errore personalizzati.

Ogni programma Rust richiede un modulo root. Per i file eseguibili, di solito è il file main.rs, mentre per le librerie è solitamente il file lib.rs.

I moduli possono essere dichiarati all'interno di altri moduli o organizzati in file e directory.

Affinché il compilatore riconosca il nostro modulo, dobbiamo usare la parola chiave mod dichiarazione. Nel nostro modulo root, dobbiamo usare la parola chiave use prima del nome del modulo, il che significa portare l'elemento nell'ambito.

Gli elementi definiti in un modulo sono privati ​​per impostazione predefinita e devono essere esposti ai chiamanti utilizzando la parola chiave pub.

Gli array hanno una lunghezza fissa e possono memorizzare elementi dello stesso tipo. Sono rappresentati da [T, N], dove T rappresenta qualsiasi tipo e N rappresenta il numero di elementi dell'array. La dimensione dell'array non può essere rappresentata da una variabile e deve essere un valore letterale di usize.

sottoargomento