Rustmatriser
Denne artikkelen vil utforske hvordan vi kan lage og bruke matriser i Rust -programmeringsspråket.
Rustmatriser
I rust, som de fleste programmeringsspråk, representerer vi en rekke av et par firkantede parenteser. Rust krever at størrelsen på en matrise blir kjent før sammenstilling. Hvis størrelsen på en matrise er udefinert ved kompileringstid, er dette kjent som en skive.
Lag rustarray
Det er to hovedmåter å lage matriser i rust:
Ved å legge elementene i matrisen til et par firkantede parenteser. Dette er den enkleste og vanligste metoden for array -oppretting. Vi kan uttrykke syntaks for denne metoden for array -oppretting som vist:
La Array_Name: [F64, 3] = [3.141, 100.2443, 223.554]Ovennevnte oppretter en matrise under variabelnavnet “Array_name”. I vårt tilfelle inneholder matrisen 64-bit signerte flytende punktverdier som spesifisert av F64-verdien. Størrelsen på matrisen er 3. Dette betyr at det kan inneholde opptil 3 elementer.
Vi refererer til den andre metoden for å lage en matrise som et gjentatt uttrykk. Syntaksen er som [n, x] der matrisen inneholder verdien av x kopieres n ganger.
Rust erklærer matrise
Det er forskjellige typer matriser i rust. Hver type bestemmes av metoden for erklæring som er brukt. Følgende er matriser og hvordan du erklærer dem.
Matriser uten størrelse og type
Den første typen matrise er en uten størrelse og type. Dette er en veldig nyttig metode for raske matriseoperasjoner.
For å erklære en matrise uten type eller størrelse, bruk syntaks som vist nedenfor:
la array_name = [elementer];Her bruker vi let -nøkkelordet, etterfulgt av navnet på variabelen. Deretter bruker vi oppdragsoperatøren, etterfulgt av elementene i matrisen inne i et par firkantede parenteser.
Et eksempel er som vist:
La arr = [1,2,3];Kompilatoren bestemmer typen av matrisen basert på elementene som er lagret i den. Det totale antall elementer i matrisen blir størrelsen.
Matriser med type og størrelse
Den andre typen matrise er en med både en type og størrelse under erklæringen. For denne typen matriser angir vi datatypen på elementene vi ønsker å lagre i matrisen og hvor mange elementer som matrisen vil holde.
Syntaksen for denne array -opprettelsen er som vist nedenfor:
la array_name: [data_type; array_size] = [array_elements];Et eksempel er som vist nedenfor:
fn main ()La arr: [i32; 3] = [1,2,3];
Ovennevnte oppretter en matrise kalt “ARR” som inneholder 3, 32-bits signerte heltall.
Arrays med standardverdier
Den tredje typen matrise i rust er en som inneholder en standardverdi. I denne typen matriser har alle elementene i matrisen en enkelt identisk verdi som du kan oppdatere når du ser passende.
Syntaksen er som vist:
la array_name: [data_type; array_size] = [default_value; array_size];Et eksempel på en slik matrise er som vist:
fn main ()La arr: [&str; 3] = ["Nil"; 3];
Eksemplet ovenfor skaper en rekke & STR og størrelse 3. Vi inkluderer også en standardverdi, "null". Derfor vil alle tre elementene i matrisen inneholde standardverdien med mindre de er oppdatert.
Rust -utskriftsarray
Vi kan skrive ut en matrise ved hjelp av println! Makro og feilsøkingstrekk i STD :: FMT. Et eksempel er som vist:
fn main ()La arr: [&str; 3] = ["Nil"; 3];
Println!(":? ", arr);
Ovennevnte kode skal skrive ut matrisen som vist:
Rustarray indeksering
Selv om vi kan skrive ut hele matrisen ved å bruke feilsøkingstrekk fra FMT -modulen, kan vi få tilgang til individuelle elementer fra matrisen ved hjelp av indeksen.
I rust starter array -indeksering på 0. Dette betyr at det første elementet i matrisen er ved indeks 0, og det andre er ved indeks 1 og så videre.
For å få tilgang til et element etter indeksen, bruker vi navnet på matrisen etterfulgt av indeksen over elementet vi ønsker å få tilgang til i et par firkantede parenteser.
Et eksempel er som vist:
fn main ()La arr: [&str; 3] = ["Nil"; 3];
Println!("", arr [0]);
Eksemplet over skal være elementet ved indeks 0 eller det første elementet i matrisen.
For å få det siste elementet i matrisen, bruker vi lengden på matrisen - 1 siden indeksering starter på 0.
Et eksempel er som vist:
fn main ()La databaser: [&str; 3] = ["MySQL", "MongoDB", "SQL Server"];
Println!("", databaser [databaser.Len () - 1]);
I eksemplet over bruker vi Len () -funksjonen for å få lengden på matrisen. Denne innebygde funksjonen returnerer lengden (antall elementer) i matrisen.
Programmet over skal returnere elementet ved indeks 2 som:
Rust iterert over matrise
En annen vanlig operasjon når du jobber med matriser er itererer over hvert element i matrisen. I rust kan vi oppnå dette ved hjelp av en for loop.
Et eksempel er som vist nedenfor:
fn main ()La databaser: [&str; 3] = ["MySQL", "MongoDB", "SQL Server"];
for jeg i 0 ... databaser.len ()
Println!("Indeks: , element: ", i, databaser [i]);
Eksempelprogrammet ovenfor bruker en enkel for loop å iterere over elementene i matrisen. For å få antall elementer i matrisen, kan vi bruke Len () -funksjonen. Inne i for -loopen får vi tilgang til hvert element basert på indeksen.
De resulterende verdiene er som vist:
Rustarray mutabilitet
Som alle variabler i rust, er matriser uforanderlige som standard. Derfor vil det å prøve å endre matrisen føre til en feil.
Et eksempel er som vist:
fn main ()La databaser: [&str; 3] = ["MySQL", "MongoDB", "SQL Server"];
databaser [0] = "PostgreSql";
Programmet over prøver å endre verdien av elementet ved indeks 0. Å kjøre koden over vil returnere en feil som vist:
Vi kan angi matrisen til Mutable ved hjelp av MUT -nøkkelordet for å unngå denne feilen. Koden er som vist nedenfor:
La MUT -databaser: [&str; 3] = ["MySQL", "MongoDB", "SQL Server"];Dette gjør matrisen mutable, slik at du kan endre verdiene slik du synes passer.
Konklusjon
Denne artikkelen utforsket hvordan du lager og bruker matriser i rust. Husk at matriser kan utvides til å gjøre så mye mer. Tenk på Rust -dokumentene for mer informasjon.