Rustvariabler

I programmering refererer en variabel til en lagringsbeholder som brukes til å lagre verdier. Enkelt sagt er en variabel et navngitt lagringssted der programmet kan lagre og hente data. Selv om det grunnleggende konseptet med en variabel er universell på tvers av programmeringsspråk, behandler Rust variabler litt annerledes.

I rust er en variabel assosiert med en bestemt type. Kompilatoren vil bruke datatypen for å bestemme utformingen av variabelenes minne og plassen til å tildele til variabelen.

I dette kjøringen vil vi utforske hvordan vi skal jobbe med variabler i rust og hvordan du bruker dem til å lagre forskjellige typer informasjon.

Rustvariabel navngiving

Som vi nevnte, er en variabel et navngitt lagringssted i et program. Dette betyr at vi må lage en identifikator som andre deler av programmet kan referere til.

Selv om det å navngi noe som en variabel kan virke veldig trivielt, er det visse regler som vi holder oss til.

Disse inkluderer:

• Et variabelt navn kan ikke starte med et siffer eller spesialtegn bortsett fra en understreking.
• Et navn kan være sammensatt av små bokstaver eller store alfanumeriske tegn eller en understreking.
• Variable navn er case-sensitive i rust. Derfor er variablene alder og alder ikke de samme.
• Selv om det ikke er et krav, definerer Rust Naming -reglene en lokal variabel som bør bruke en slangesak for å bli med på navn. For eksempel total_punkter i stedet for totalpunkter.

Ovennevnte er noen navneregler å følge når du navngir en variabel. Du kan sjekke rustnavnreglene i ressursen nedenfor:

https: // rust-lang.github.IO/API-retningslinjer/navngiving.html

Rustvariabel erklæring

Vi kan erklære en variabel ved hjelp av let- eller const -nøkkelordet. Etter let -nøkkelordet angir vi navnet på variabelen og datatypen.

Syntaksen er som vist:

La variabel_navn: type;

Et eksempelprogram med variabel erklæring er som vist:

fn main ()
La URL:&str;

Ovennevnte erklærer en variabel kalt URL av Type & Str.

Type merknad i rust er valgfritt. Dette betyr at kompilatoren kan utlede typen fra verdien som er tilordnet variabelen.

Et eksempel på variabel erklæring uten type merknad er vist nedenfor:

fn main ()
La URL = "https: // linuxhint.com ";

Const -nøkkelordet i rust lar deg definere konstantvariabler. I motsetning til let -nøkkelordet, må du utføre type merknad når du bruker Const -nøkkelordet.

Et eksempel er som vist:

fn main ()
const url: & str = "https: // linuxhint.com ";

Vi kan ikke endre verdien av en konstant verdi senere i programmet etter erklæring. En konstant vil også leve for programmets levetid og har ingen fast minneadresse.

MERK: Konstanter er grunnleggende uforanderlige, i motsetning til ikke støtter nøkkelordet MUT. Sjekk variable mutabilitetsseksjoner for å lære mer.

Sekund: Verdien av en konstant må være, vel, konstant. Ikke angi verdien av en Const -variabel til et uttrykk som skal evalueres ved kjøretid.

Tredje: Selv om de følger reglene for variabel navngiving. Konstanter bruker skriking_snake_case for navnene sine.

Rustvariabel mutabilitet

I rust er variabler uforanderlige objekter som standard. Dette betyr at vi ikke kan endre verdiene deres etter erklæring.

Ta eksemplet nedenfor:

fn main ()
La URL = "https: // linuxhint.com ";
url = "https: // google.com ";

Hvis vi sammenstiller koden over, bør vi få en feil som vist nedenfor:

Ovennevnte utgang viser at kompilatoren ikke tillater omfordeling av variabler som standard.

Rust lar deg imidlertid lage mutable variabler. Du kan bruke mut -nøkkelordet under funksjonserklæringen for å gjøre det mutable.

Tenk på eksemplet nedenfor:

fn main ()
La mut url = "https: // linuxhint.com ";
url = "https: // google.com ";

Programmet over oppretter en mutbar variabel kalt URL. Vi kan nå tilordne verdien senere i programmet.

Rustvariabel skygge

Rust tilbyr en funksjon kjent som skygge; Vel, de fleste rustaceans refererer det til det. Det er en funksjon der du kan erklære en variabel med samme navn som en variabel som allerede er erklært og angi en ny verdi eller type for den.

Jeg liker å tenke på det som en måte å introdusere midlertidig mutabilitet til en variabel.

Ta eksempelprogrammet nedenfor:

fnMain ()
leturl = "https: // linuxhint.com ";

// den andre variabelen skygger den første
leturl = "https: // google.com ";
Println!("", url);

Println!("", url);

I programmet over erklærer vi en uforanderlig variabel kalt URL i det globale omfanget. Vi oppretter deretter et indre omfang som innhenter URL -variabelen og tildeler det en ny verdi. URL -variabelen i det indre omfanget skygger den globale variabelen i dette tilfellet.

Hvis vi kjører programmet over, bør vi få en produksjon som:

Husk at variabel skygge skiller seg fra variabel mutabilitet. Dette er fordi,

• Vi oppretter en ny variabel når vi bruker nøkkelordet.
• Denne funksjonaliteten er ustabil, og funksjonen forblir uforanderlig, men med en ny verdi.

Lukking

Vi har undersøkt hvordan variabler fungerer i rustprogrammeringsspråket. Fortsett å øve eller sjekke dokumentasjonen for å lære mer.