Tuple ruggine

Una tupla è definita come un tipo di dati composto che consente di archiviare una raccolta di valori di un tipo diverso. In ruggine, una tupla è implementata come struttura e non deve essere utilizzata in sostituzione di un array.

Ci immergiamo in profondità e impariamo come possiamo lavorare con le tuple in ruggine.

Rust crea tupla

In Rust, creiamo una tupla usando una coppia di parentesi. Esistono due modi fondamentali per creare una tupla in ruggine:

1. Senza inferenza di tipo.
2. Senza inferenza di tipo.

La sintassi seguente illustra come creare una tupla senza inferenza di tipo:

let tuple_name = (valori);

Il secondo metodo per creare una tupla è quello in cui deduciamo il tipo.

let tuple_name: (data_type_1, data_type_2,…) = (value_1, value_2,…);

Sebbene il metodo di cui sopra sia supportato, tende a confondere al primo utilizzo.

Un esempio di tupla senza inferenza di tipo è come mostrato di seguito:

fnMain ()
let tuple = (1,2,3,4,5, "a,", "b", "c");

Quanto sopra crea una tupla di diversi tipi senza inferenza di tipo. Il compilatore assegnerà automaticamente i tipi agli elementi della tupla.

Considera l'esempio seguente che mostra come creare una tupla con inferenza del tipo.

let tuple2: (i32, & str) = (1, "a");

Nell'esempio della sintassi sopra, raccontiamo esplicitamente al compilatore il tipo di valori che desideriamo archiviare. Ricorda che l'ordine è importante e ogni elemento deve corrispondere al tipo definito.

Possiamo stampare una tupla usando il tratto di debug dal modulo std :: fmt. Un esempio è come mostrato:

fnMain ()
let tuple = (1,2,3,4,5, "a,", "b", "c");
println!(":? ", tuple);

Il programma sopra restituisce gli elementi della tupla:

(1, 2, 3, 4, 5, "a,", "b", "c")

Elementi tuple di accesso alla ruggine

Per accedere a un elemento di una tupla, utilizziamo il suo indice corrispondente. In Rust, un'indicizzazione Tuple inizia a 0.

La sintassi per l'accesso a un elemento in un indice specifico è mostrata:

tuple_name.indice

In Rust, utilizziamo la notazione punto per accedere a un elemento in un indice specifico. Questo perché una tupla è tecnicamente una struttura in ruggine.

Considera l'esempio seguente che accede a un elemento all'indice 5 nella tupla.

fn main ()
let tuple = (1,2,3,4,5, "a,", "b", "c");
// let tuple2: (i32, & str) = (1, "a");
println!(":? ", tuple.5);

Il programma restituisce l'elemento all'indice 5; In questo caso, restituisce "A".

Suggerimento: le tuple non consentono looping. Quindi, non possiamo usare una funzione come un ciclo per iterare su ogni elemento nella tupla.

Rust tuple disimballaggio

Rust ti consente di disimballare gli elementi di una tupla in singoli valori. Possiamo farlo usando la sintassi mostrata di seguito:

let (valori ...) = tuple_name;

Di seguito è mostrato un esempio di disimballaggio di Tuple:

fn main ()
let tuple = (20, "Aaron", 131000);
let (età, nome, stipendio) = tuple;
println!("Nome: \ nage: \ nsalary: \ n", nome, età, stipendio)

L'esempio sopra disimballa gli elementi in singole variabili. Questa è una caratteristica molto utile che consente di utilizzare elementi specifici di una tupla individualmente.

Conclusione

Questa guida esplora come lavorare con le tuple e i tipi di tupla nel linguaggio di programmazione della ruggine. La ruggine tratta le tuple in modo diverso dagli altri linguaggi di programmazione, come Python. Controlla la documentazione per esplorare di più.

Grazie per la lettura e la codifica felice!!