Tipi di dati ruggine
I tipi di dati sono una caratteristica universale tra molti linguaggi di programmazione e forniscono un solido blocco per i programmi che costruiamo con esso. Tieni presente che ogni lingua ha i suoi tipi che possono differire dalle altre lingue.
Come programmatori, conoscere i vari tipi primitivi forniti da un linguaggio è più che cruciale. Quindi, per questo tutorial, attraverseremo i vari tipi nel linguaggio di programmazione della ruggine.
Tipi primitivi ruggine
Esistono due categorie principali per i tipi primitivi di ruggine:
- Tipi scalari
- Tipi composti
Tuttavia, non importa se un tipo è scalare o composto, tutto ciò che devi sapere è come usarlo nei programmi.
Iniziamo con i tipi più comuni e di base in Rust:
Numeri interi
La prima categoria di tipi primitivi in ruggine sono numeri interi. Un intero è un tipo di numero che non ha un valore frazionario. Esistono vari tipi di tipi interi in ruggine e includono:
- i8
- U8
- i16
- U16
- i32
- U32
- i64
- U64
- i128
- U128
- isino
- usize
Ogni tipo intero prende il formato di:
letteraLa lettera in questo caso indica se il numero può avere un segno. Se il tipo è firmato (i), può avere un valore negativo. Se non firmato (U), il numero sarà solo positivo.
Il valore del numero rappresenta la dimensione nei bit che il tipo occuperà in memoria. Ad esempio, un valore I32 rappresenta un numero intero firmato a 32 bit.
Il tipo di isini o usize dipenderà dall'architettura da cui è in esecuzione il codice. Se sei su architettura a 32 bit, il tipo occuperà 32 bit e 64 bit per architetture a 64 bit.
NOTA: Assicurati di mantenere i tuoi valori all'interno dell'intervallo dei tipi specificati. Altrimenti, hai un overflow che può portare a operazioni pericolose.
Il programma di esempio seguente mostra come dichiarare e utilizzare i tipi interi in ruggine.
fn main ()// Tipi interi
let i_8 = -128;
let u_8 = 127;
let i_16 = -32768;
let u_16 = 32767;
let i_32 = -2147483648;
let u_32 = 2147483647;
Let I_64 = -9223372036854775808_I64;
let u_64 = 9223372036854775807_U64;
Let I_128 = -17014118346046923173168730371588884105728_i128;
Let U_128 = 1701411834604692317316873037158884105727_U128;
let i_size = -9223372036854775808_ISIZE;
let u_size = 9223372036854775807_usize;
println!; ni_128 -> \ nu_128 -> \ ni_size -> \ nu_size -> ", i_8, u_8, i_16, u_16, i_32, u_32, i_64, u_64, i_128, u_128, i_size);
Il programma sopra mostra come dichiarare i tipi int in ruggine. Questo dovrebbe stampare:
NOTA: Se non si specifica il tipo quando si assegna un valore numerico, la ruggine verrà impostata in modo predefinito in un tipo i32.
Tipo galleggiante
Rust ha numeri di tipo galleggiante. Questi sono numeri che includono valori di punta mobile o punti decimali. Esistono solo due tipi di tipi galleggianti in ruggine: F32 e F64 che sono valori a 32 e 64 bit.
Esempio di tipo galleggiante sono come mostrato:
Sia F_32 = 3.141_F32; // Tipo mobile a 32 bitSia F_64 = 3.141; // Tipo mobile a 64 bit
Se non si specifica il tipo per un valore mobile, la ruggine sarà impostata sul tipo F64.
Booleani
L'altro tipo fornito da Rust è un booleano. Come tutti i valori della logica booleana, ha due possibili valori: vero o falso. Un booleano è di un byte di dimensioni.
L'esempio è come mostrato:
Let var1 = true;Let var2 = false;
Tipo di carattere
Il tipo di personaggio si riferisce a un singolo carattere Unicode. È di 4 byte di dimensioni. Ad esempio, quanto segue mostra vari tipi di tipi di char unicode.
Lascia che a = 'a';let emoji = '😊';
let pi = 'π';
Let Great = '大';
Gli esempi di codice sopra rappresentano vari caratteri Unicode.
Array
La seconda categoria di tipi primitivi in ruggine è i tipi composti. Un array fa parte del tipo composto.
Un array si riferisce a una raccolta ordinata di valori di tipi simili. Il codice seguente mostra un array in ruggine:
LET LETTERE: [&str; 5] = ["a", "b", "c", "d", "e"];In Rust, dichiariamo un array usando la parola chiave let seguita dal nome variabile, un colonico e il tipo e le dimensioni all'interno di una staffa quadrata.
Fette
Le fette sono strettamente simili agli array tranne che sono dinamiche. A differenza di un array, una fetta può crescere o ridurre di dimensioni.
Un esempio è come mostrato:
let SLC = [1,2,3,4,5];TUPLE
L'altro tipo di tipi di dati dei composti in ruggine è una tupla. Una tupla è definita una sequenza eterogenea di valori. Una tupla può contenere valori di più tipi a differenza di un array. Le tuple hanno anche un ordine ed è possibile accedere tramite i loro indici. Controlla il nostro tutorial su Rust Tuples per saperne di più.
Un esempio di tupla ruggine è come mostrato di seguito:
let tup = (1,2,3,4,5); // Nessuna annotazione di tipolet tup_letter: (i32, & str, f64, char) = (100, "ciao", 3.141, 'a'); // Annotazione di tipo esplicita
Nella prima tupla, lasciamo che il compilatore ruggine deduce il tipo in base ai valori forniti.
Per il secondo, diciamo esplicitamente al compilatore quali tipi vogliamo. Tieni presente che l'ordine conta in questo tipo di dichiarazione.
Conclusione
Da questo tutorial, noti che Rust ci fornisce una suite di fantastici tipi primitivi. Ci consentono di gestire vari tipi di dati e controllare i dati che arrivano o usciti dalle nostre applicazioni.
Grazie per aver letto!