Rust è un moderno linguaggio di programmazione tipizzato staticamente progettato per prestazioni, affidabilità e sicurezza. Come in altri linguaggi tipizzati staticamente, dichiari i tipi di dati di Rust in fase di compilazione. In questo modo è più facile rilevare gli errori di tipo prima di eseguire il codice.
Rust offre tipi scalari, composti, di riferimento, struct, enum e stringhe. La sua inferenza di tipo fornisce funzionalità per la scrittura di codice conciso mantenendo la sicurezza di un linguaggio tipizzato staticamente.
Interi in Rust
Rust fornisce interi con e senza segno classificati in base al numero di bit. I tipi interi con segno sono i8, i16, io32, E i64 che rappresentano rispettivamente interi con segno a 8 bit, 16 bit, 32 bit e 64 bit. Supporta anche i tipi interi senza segno u8, u16, u32, E u64, che rappresenta numeri interi senza segno a 8 bit, 16 bit, 32 bit e 64 bit.
// interi con segno
permettere a: i8 = -10;
permettere b: i16 = -2048;
permettere c: i32 = -2147483648;
permettere d: i64 = -9223372036854775808;
// interi senza segno
permettere e: u8 = 255;
permettere f: u16 = 65535;
permettere g: u32 = 4294967295;
permettere h: u64 = 18446744073709551615;
Rust usa il io32 digitare per valori letterali interi per impostazione predefinita.
Tipi di virgola mobile ruggine
La ruggine fornisce f32 E f64 come tipi a virgola mobile che rappresentano numeri a virgola mobile a precisione singola e doppia. IL f32 type utilizza 32 bit per memorizzare i valori e il f64 type utilizza 64 bit.
I numeri in virgola mobile in Rust seguono lo standard IEEE 754 per l'aritmetica in virgola mobile.
permettere un = 3.14159265358979323_f32;
permettere b = 2.718281828459045235_f64;
Usare i booleani di Rust
La ruggine fornisce un bool tipo da rappresentare VERO O falso valori. I booleani sono spesso usati nelle istruzioni del flusso condizionale e di controllo per il processo decisionale del programma.
permettere variabile_1: bool = VERO;
permettere variabile_2: bool = falso;
Puoi confrontare i valori booleani con l'operatore di uguaglianza, ==, e l'operatore di disuguaglianza, !=. Rust non definisce gli operatori di confronto, , <=, E >=, per bool valori.
permettere variabile_1: bool = VERO;
permettere variabile_2: bool = falso;
if variabile_1 == variabile_2 {
stampa!("variabile_1 è uguale a variabile_2");
} altroSe variabile_1 != variabile_2 {
stampa!("variabile_1 non è uguale a variabile_2");
}
Il tipo di carattere
La ruggine char type rappresenta un singolo valore scalare Unicode che può rappresentare qualsiasi carattere in lo standard Unicode. Puoi specificare un char valore utilizzando virgolette singole.
// Dichiarazione di un valore char
permettere c = 'UN';
IL char type è utile per lavorare con gli emoji in Rust.
Tuple in Rust
La struttura dati tupla consente di raggruppare più di un valore in un singolo valore composto. Questi valori possono avere lo stesso tipo o tipi diversi. È possibile dichiarare le tuple scrivendole come un elenco di valori separati da virgole e racchiusi tra parentesi.
Ecco come dichiarare una tupla con numeri interi a 32 bit, stringhe e valori float64.
permettere tup: (i32, &str, f64) = (500, "Ciao", 3.14);
Le tuple hanno una lunghezza fissa e puoi usarle per restituire più valori da una funzione o passare più valori a funzioni come un singolo argomento.
È possibile accedere ai singoli elementi di una tupla destrutturandola utilizzando il pattern matching o accedendo direttamente ai singoli elementi utilizzando la sintassi punto (.) e un indice.
Ecco come puoi accedere ai singoli elementi di una struttura utilizzando il pattern matching:
permettere mia_tupla = (10, "Ciao mondo!", falso);permettere (x, y, z) = mia_tupla;
stampa!("Il primo elemento è: {}", X);
stampa!("Il secondo elemento è: {}", y);
stampa!("Il terzo elemento è: {}", z);
Ecco come puoi accedere ai singoli elementi utilizzando la notazione punto:
permettere mia_tupla = (10, "Ciao mondo!", falso);
println!("ILPrimoelementoÈ: {}", mia_tupla.0);
println!("ILsecondoelementoÈ: {}", mia_tupla.1);
println!("ILterzoelementoÈ: {}", mia_tupla.2);
Le tuple sono molto utili quando si raggruppano dati correlati in un unico valore. Possono anche migliorare la leggibilità del tuo codice se li usi con parsimonia.
Array in ruggine
Un array è una raccolta di elementi dello stesso tipo con una lunghezza fissa. Scrivi gli array Rust come un elenco di valori tra parentesi quadre, separati da virgole.
Ecco come puoi dichiarare gli array in Rust:
permettere ar = [1, 2, 3, 4, 5];
Non è possibile modificare il numero di elementi in un array dopo averlo dichiarato, ma è possibile accedere, modificare e manipolare i singoli elementi di un array utilizzando l'indicizzazione.
permettere mut my_array = [1, 2, 3, 4, 5];// Accesso agli elementi
println!("ILPrimoelementoÈ: {}", my_array[0]);// Modifica elementi
mio_array[0] = 100;
println!("ILPrimoelementoDopomodificaÈ: {}", my_array[0]);// Ciclo su un array e manipolazione di elementi
perioIn 0..my_array.len() {
mio_array[i] *= 2;
}
// stampa l'array
stampa!("L'array dopo la manipolazione: {:?}", mio_array);
Gli array di ruggine lo sono memorizzato sulla pila e hanno un'allocazione di memoria contigua, quindi l'accesso agli elementi di un array è veloce ed efficiente. Ciò rende gli array adatti a situazioni in cui è necessario archiviare ed elaborare molti elementi.
Lavorare con fette di ruggine
Una sezione è una struttura di dati che consente di fare riferimento a una sequenza contigua di elementi in una raccolta. Le fette sono rappresentate da &[T] type, dove T è il tipo di elementi archiviati nella slice.
fn principale(){
// dichiara un array
permettere mio_array = [1, 2, 3, 4, 5];// crea una sezione dall'array
permettere mia_fetta = &mio_array[1..3];
// stampa la fetta
stampa!("Fetta: {:?}", mia_fetta);
}
Nota come la sintassi dell'intervallo, .., estrae una slice da un array utilizzando l'indice iniziale e un indice maggiore di uno alla fine:
Le sezioni sono dinamiche, quindi Rust può determinarne la lunghezza in fase di esecuzione. Puoi anche passare le sezioni come argomenti alle funzioni senza la necessità di allocare l'heap.
Utilizzerai comunemente le sezioni per le operazioni sulle stringhe e per passare sottoinsiemi di dati alle funzioni. Sono uno strumento potente ed efficiente per la gestione delle raccolte in Rust, fornendo un'alternativa più flessibile agli array.
Puoi creare app Web front-end basate su WebAssembly in Rust
La conoscenza dei tipi di dati è fondamentale per il tuo viaggio in Rust poiché li utilizzerai per la maggior parte delle operazioni durante la creazione di applicazioni.
WebAssembly è un formato binario di basso livello che viene eseguito su browser Web moderni, con prestazioni quasi native. Ti consente di scrivere codice in molti linguaggi diversi e di trasferirlo in WebAssembly.
WebAssembly sta ottenendo l'adozione tramite Rust. Esistono molti framework come Yew, Sycamore e Seed che puoi utilizzare per creare frontend basati su WebAssembly con Rust.
