Rustoperatører

Som i det virkelige liv hjelper operatører i programmeringen oss til å definere og utføre spesifikke funksjoner ved hjelp av et programmeringsspråk. Ethvert programmeringsspråk for selvresultat gir et sett med operatører som vi kan bruke til å utføre operasjoner. Vanlige operatører inkluderer matematiske operatører, logiske operatører osv.

Denne guiden vil diskutere hvordan man jobber med forskjellige operatører levert av Rust -programmeringsspråket.

La oss komme i gang ..

R8ust -operatører

Rust gir følgende sett med operatører:

1. Aritmetiske operatører
2. Logiske operatører
3. Sammenligningsoperatører
4. Bitvis operatører
5. Sammensatte tildelingsoperatører

Rust aritmetiske operatører

Som navnet antyder, tillater aritmetiske operatører oss å utføre aritmetiske operasjoner på et sett med operander. Vanlige matematiske operasjoner inkluderer tillegg, subtraksjon, divisjon osv.

Følgende er det populære settet med aritmetiske operatører:

Operatørsymbol	Operatørnavn	Beskrivelse
+	Aritmetisk tillegg	Returnerer summen av to eller flere operander
-	Aritmetisk subtraksjon	Returner forskjellen mellom to eller flere operander.
*	Aritmetisk multiplikasjon	Returnerer produktet av to eller flere operander
/	Aritmetikk Division	Returnerer kvotienten til venstre operandutbytte av høyre operand
%	Aritmetikk resten.	Returnerer resten fra divisjonen av venstre operand av høyre operand.

Vi kan illustrere hvordan du bruker aritmetiske operatører i rust som vist nedenfor:

fn main ()
// aritmetiske operatører
La x = 10;
La y = 2;
Println!("Sum: ", x + y);
Println!("Differnce: ", x - y);
Println!("Produkt: ", x * y);
Println!("Kvotient: ", x / y);
Println!("Modulo: ", x % y);

Koden over skal returnere:

Rust logiske operatører

Den andre kategorien av operatører støttet av Rust Lang er logiske operatører. Denne typen operatører brukes til å kombinere to eller flere boolske forhold. Logiske operatører vil alltid returnere en boolsk verdi.

De inkluderer:

Operatørsymbol	Operatørnavn	Beskrivelse
&&	Kortslutning Logisk og	Returnerer sant hvis alle de spesifiserte forholdene evalueres til å være sanne.
||	Kortslutning logisk eller	Returnerer sant hvis minst en av de spesifiserte forholdene er sant.
!	Logisk ikke	Negerer resultatet av et boolsk uttrykk. Hvis tilstanden er sann, returnerer ikke operatøren falsk.

Eksempel Kodeimplementering er som vist:

fn main ()
// aritmetiske operatører
La x = sant;
La y = falsk;
Println!("Logisk og: ", (x && y));
Println!("Logisk eller: ", (x || y));
Println!("Logisk ikke: ", (!x));
Println!("Logisk ikke: ", (!y));

Koden over skal returnere som:

Rust sammenligningsoperatører

Sammenligningsoperatører sammenligner to operander og returnerer en boolsk verdi basert på tilstanden.

Disse operatørene inkluderer:

Operatørsymbol	Operatørnavn	Beskrivelse
>	Større enn	Returnerer sant hvis operand til venstre er større enn høyre operand.
<	Mindre enn	Returnerer sant hvis venstre operand er mindre enn høyre operand.
> =	Større enn eller lik	Returnerer sant hvis venstre operand er større enn eller lik høyre operand.
<=	Mindre enn eller lik	Returnerer sant hvis venstre operand er mindre enn eller lik høyre operand.
==	Lik	Returner sann hvis venstre operand er lik høyre operand.
!=	Ikke lik	Returnerer sant hvis venstre operand ikke er lik høyre operand.

Vi kan illustrere bruken av sammenligningsoperatørene, som vist i koden nedenfor:

fn main ()
La x = 10;
La y = 2;
Println!("er x større enn y: ", (x> y));
Println!("er x mindre enn y: ", (x < y));
Println!("er x lik y: ", (x == y));
Println!("er x større enn eller lik: ", (x> = y));
Println!("er x mindre enn eller lik: ", (x <= y));
Println!("x er ikke lik y: ", (x != y));

Koden over skal returnere:

Rust bitvis operatører

Bitvise operatører er vant til å utføre bitvis operasjoner. De inkluderer:

Operatørsymbol	Operatørnavn	Beskrivelse
Og	Bitvis og	Utfører boolsk og på hver bit.
|	Bitvis eller	Utføre boolsk eller på hver bit
^	Bitvis xor	Utfører eksklusiv boolsk eller på hver bit.
!	Bitvis ikke	Utfører unary ikke.
<<	Venstre bitshift	skifter venstre bit operand til venstre med beløpet som er spesifisert av høyre operand.
>>	Høyre bitshift	Skifter venstre operand av verdien som er spesifisert av riktig operand.

Et eksempel på kildekoden vises nedenfor:

fn main ()
La x = 10;
La y = 2;
Println!("Bitwise og: ", (x & y));
Println!("Bitvis eller: ", (x | y));
Println!("Bitvis eksklusiv eller: ", (x ^ y));
Println!("Venstre bitshift ", (x << y));
Println!("Right Bitshift: ", (x >> y));
Println!("Bitvis ikke: ", (!x));

Koden over skal returnere utdata som vist:

Bitvis og: 2
Bitvis eller: 10
Bitvis eksklusiv eller: 8
Venstre bitshift 40
Høyre bitshift: 2
Bitvis ikke: -11

Rustforbindelsesoppgaveoperatører

Forbindelsesoperatører brukes til å tilordne verdien til høyre til verdien til venstre. Disse inkluderer:

Operatørsymbol	Operatørnavn
+=	Aritmetisk tillegg og tildeling
-=	Aritmetisk subtraksjon og tildeling
*=	Aritmetisk multiplikasjon og tildeling
/=	Aritmetikkinndeling og tildeling
>> =	Høyre skift og tildeling
<<=	Venstre-skift og oppgave
%=	Aritmetikk resten og tildeling
& =	Bitvis og og tildeling
| =	Bitvis eller og tildeling
^=	Bitvis eksklusiv eller og tildeling

Konklusjon

Denne artikkelen diskuterte rustoperatører og hvordan vi kan bruke dem i programmene våre. Sjekk rustdokumentasjonen for å utforske.

Takk for at du leser!!