Operatori di ruggine

Come nella vita reale, gli operatori della programmazione ci aiutano a definire ed eseguire funzioni specifiche utilizzando un linguaggio di programmazione. Qualsiasi linguaggio di programmazione autosuocabile fornisce un insieme di operatori che possiamo utilizzare per eseguire operazioni. Gli operatori comuni includono operatori matematici, operatori logici, ecc.

Questa guida discuterà come lavorare con vari operatori forniti dal linguaggio di programmazione Rust.

Iniziamo ..

Operatori r8ust

Rust fornisce il seguente set di operatori:

1. Operatori aritmetici
2. Operatori logici
3. Operatori di confronto
4. Operatori bitwise
5. Operatori di assegnazione composti

Operatori aritmetici ruggine

Come suggerisce il nome, gli operatori aritmetici ci consentono di eseguire operazioni aritmetiche su una serie di operandi. Le operazioni matematiche comuni includono aggiunta, sottrazione, divisione, ecc.

Di seguito sono riportati l'insieme popolare di operatori aritmetici:

Simbolo dell'operatore	Nome dell'operatore	Descrizione
+	Aggiunta aritmetica	Restituisce la somma di due o più operandi
-	Sottrazione aritmetica	Restituire la differenza tra due o più operandi.
*	Moltiplicazione aritmetica	Restituisce il prodotto di due o più operandi
/	Divisione aritmetica	Restituisce il quoziente del dividendo dell'opera e sinistro da parte dell'operando destro
%	Resto aritmetico.	Restituisce il resto dalla divisione dell'operando sinistro da parte dell'operando destro.

Possiamo illustrare come usare gli operatori aritmetici in ruggine come mostrato di seguito:

fn main ()
// operatori aritmetici
Sia x = 10;
Sia y = 2;
println!("Sum: ", x + y);
println!("Difference: ", x - y);
println!("Prodotto: ", x * y);
println!("Quoziente: ", x / y);
println!("Modulo: ", x % y);

Il codice sopra dovrebbe restituire:

Operatori logici ruggine

La seconda categoria di operatori supportati da Rust Lang è gli operatori logici. Questi tipi di operatori vengono utilizzati per combinare due o più condizioni booleane. Gli operatori logici restituiranno sempre un valore booleano.

Loro includono:

Simbolo dell'operatore	Nome dell'operatore	Descrizione
&&	Corto circuito logico e	Restituisce vero se tutte le condizioni specificate valutano come vere.
||	Corto circuito logico o	Restituisce vero se almeno una delle condizioni specificate è vera.
!	Logico no	Nega il risultato di un'espressione booleana. Se la condizione è vera, l'operatore non restituisce falso.

L'implementazione del codice di esempio è come mostrato:

fn main ()
// operatori aritmetici
Sia X = True;
Sia y = false;
println!("Logico e: ", (x && y));
println!("Logico o: ", (x || y));
println!("Logico no: ", (!X));
println!("Logico no: ", (!y));

Il codice sopra dovrebbe restituire come:

Operatori di confronto ruggine

Gli operatori di confronto confrontano due operandi e restituiscono un valore booleano in base alla condizione.

Questi operatori includono:

Simbolo dell'operatore	Nome dell'operatore	Descrizione
>	Più grande di	Restituisce vero se l'operando a sinistra è maggiore dell'operando destro.
<	Meno di	Restituisce vero se l'operando sinistro è inferiore all'operando destro.
> =	Maggiore o uguale a	Restituisce vero se l'operando sinistro è maggiore o uguale all'operando destro.
<=	Minore o uguale a	Restituisce vero se l'operando sinistro è inferiore o uguale all'operando destro.
==	Uguale a	Restituisce true se l'operando sinistro è uguale a destra.
!=	Non uguale a	Restituisce vero se l'operando sinistro non è uguale a destra.

Possiamo illustrare l'uso degli operatori di confronto, come mostrato nel codice seguente:

fn main ()
Sia x = 10;
Sia y = 2;
println!("è x maggiore di y: ", (x> y));
println!("è x meno di y: ", (x < y));
println!("è x uguale a y: ", (x == y));
println!("è x maggiore o uguale a: ", (x> = y));
println!("è x inferiore o uguale a: ", (x <= y));
println!("x non è uguale y: ", (x != y));

Il codice sopra dovrebbe restituire:

Operatori di ruggine bitwise

Gli operatori di bit sono usati per eseguire operazioni bitwise. Loro includono:

Simbolo dell'operatore	Nome dell'operatore	Descrizione
E	Bitwise e	Si esibisce booleano e su ogni bit.
|	Bitwise o	Esegui booleano o su ogni bit
^	Bitwise xor	Esegue esclusivi booleani o su ogni bit.
!	Bitly no	Si comporta unerico no.
<<	BiTshift sinistro	Sposta l'operando a sinistra a sinistra per l'importo specificato dall'operando destro.
>>	BiTshift giusto	Cambia l'operando sinistro dal valore specificato dall'operando destro.

Di seguito viene mostrato un codice sorgente di esempio:

fn main ()
Sia x = 10;
Sia y = 2;
println!("Bitwise e: ", (x & y));
println!("Bitwise o: ", (x | y));
println!("Bitwise esclusivo o: ", (x ^ y));
println!("Left Bitshift ", (x << y));
println!("BitShift Right: ", (x >> y));
println!("Bitwise no: ", (!X));

Il codice sopra dovrebbe restituire l'output come mostrato:

Bitwise e: 2
Bitwise o: 10
Bitwise esclusivo o: 8
Sinistro BitShift 40
BiTshift giusto: 2
Bitly Not: -11

Operatori di assegnazione dei composti arrugginiti

Gli operatori di assegnazione composti vengono utilizzati per assegnare il valore a destra al valore a sinistra. Questi includono:

Simbolo dell'operatore	Nome dell'operatore
+=	Aggiunta e assegnazione aritmetica
-=	Sottrazione e assegnazione aritmetica
*=	Moltiplicazione e assegnazione aritmetica
/=	Divisione aritmetica e assegnazione
>> =	Spostamento destro e incarico
<<=	Spegno sinistro e incarico
%=	Resto e assegnazione aritmetico
& =	Bitwise e e assegnazione
| =	Bitwise o e assegnazione
^=	Bitwise esclusivo o assegnazione

Conclusione

Questo articolo ha discusso degli operatori ruggine e di come possiamo usarli nei nostri programmi. Controlla la documentazione di Rust per esplorare.

Grazie per aver letto!!