Rust tuples

En tuple er definert som en sammensatt datatype som lar deg lagre en samling av verdier av en annen type. I rust implementeres en tuple som en struktur, og den skal ikke brukes som erstatning for en matrise.

La oss dykke dypt og lære hvordan vi kan jobbe med tuples i rust.

Rust skap tuple

I rust lager vi en tuple ved å bruke et par parenteser. Det er to grunnleggende måter å skape en tupel i rust:

1. Uten type inferens.
2. Uten type inferens.

Syntaksen nedenfor illustrerer hvordan du lager en tuple uten type inferens:

La tuple_name = (verdier);

Den andre metoden for å lage en tuple er en der vi utleder typen.

La tuple_name: (data_type_1, data_type_2, ...) = (verdi_1, verdi_2, ...);

Selv om den ovennevnte metoden for oppretting av tuple støttes, har den en tendens til å være forvirrende ved første bruk.

Et eksempel på en tuple uten type slutning er som vist nedenfor:

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

Ovennevnte skaper en tuple av forskjellige typer uten type inferens. Kompilatoren vil automatisk tilordne typene til elementene i tupelen.

Tenk på eksemplet nedenfor som viser hvordan du oppretter en tupel med type inferens.

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

I eksemplet syntaks ovenfor, forteller vi eksplisitt kompilatoren om hvilken type verdier vi ønsker å lagre. Husk at ordren er viktig, og hvert element må samsvare med den definerte typen.

Vi kan trykke en tuple ved hjelp av feilsøkingstrekk fra STD :: FMT -modulen. Et eksempel er som vist:

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

Programmet over returnerer elementene i tupelen:

(1, 2, 3, 4, 5, "A,", "B", "C")

Rust tilgang Tuple -elementer

For å få tilgang til et element i en tupel, bruker vi den tilsvarende indeksen. I rust starter en tupleindeksering på 0.

Syntaksen for tilgang til et element på en spesifikk indeks er som vist:

tuple_name.indeks

I rust bruker vi prikknotasjonen for å få tilgang til et element i en bestemt indeks. Dette er fordi en tuple teknisk sett er en struktur i rust.

Tenk på eksemplet nedenfor som får tilgang til et element ved indeks 5 i tupelen.

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

Programmet returnerer elementet ved indeks 5; I dette tilfellet returnerer det “a”.

Tips: tuples tillater ikke looping. Derfor kan vi ikke bruke en funksjon som en for loop for å iterere over hvert element i tupelen.

Rust tuple pakket ut

Rust lar deg pakke ut elementene i en tuple til individuelle verdier. Vi kan gjøre dette ved å bruke syntaks vist nedenfor:

La (verdier ...) = tuple_name;

Et eksempel på pakking av tuple vises nedenfor:

fn main ()
La tuple = (20, "Aaron", 131000);
La (alder, navn, lønn) = tuple;
Println!("Navn: \ nage: \ nsalary: \ n", navn, alder, lønn)

Eksemplet ovenfor pakker ut elementene i individuelle variabler. Dette er en veldig nyttig funksjon som lar deg bruke spesifikke elementer i en tuple individuelt.

Konklusjon

Denne guiden utforsker hvordan du jobber med tuples og tupeltyper i rustprogrammeringsspråket. Rust behandler tuples annerledes enn andre programmeringsspråk, for eksempel Python. Sjekk dokumentasjonen for å utforske mer.

Takk for at du leser og lykkelig koding!!