Opérateurs de rouille

Comme dans la vraie vie, les opérateurs de la programmation nous aident à définir et à remplir des fonctions spécifiques à l'aide d'un langage de programmation. Tout langage de programmation auto-respect fournit un ensemble d'opérateurs que nous pouvons utiliser pour effectuer des opérations. Les opérateurs communs comprennent les opérateurs mathématiques, les opérateurs logiques, etc.

Ce guide discutera de la façon de travailler avec divers opérateurs fournis par le langage de programmation Rust.

Laissez-nous commencer…

Opérateurs R8UST

Rust fournit l'ensemble d'opérateurs suivants:

1. Opérateurs arithmétiques
2. Opérateurs logiques
3. Opérateurs de comparaison
4. Opérateurs
5. Opérateurs d'attribution composés

Opérateurs arithmétiques de la rouille

Comme son nom l'indique, les opérateurs arithmétiques nous permettent d'effectuer des opérations arithmétiques sur un ensemble d'opérandes. Les opérations mathématiques courantes comprennent l'addition, la soustraction, la division, etc.

Voici l'ensemble populaire d'opérateurs arithmétiques:

Symbole de l'opérateur	Nom de l'opérateur	Description
+	Ajout arithmétique	Renvoie la somme de deux opérandes ou plus
-	Soustraction arithmétique	Retourner la différence entre deux ou plusieurs opérandes.
*	Multiplication arithmétique	Renvoie le produit de deux opérandes ou plus
/ /	Division arithmétique	Renvoie le quotient du dividende de l'opérande gauche par l'opérande droit
%	Reste arithmétique.	Renvoie le reste de la division de l'opérande gauche par l'opérande droit.

Nous pouvons illustrer comment utiliser les opérateurs arithmétiques dans la rouille comme indiqué ci-dessous:

fn main ()
// Opérateurs arithmétiques
Soit x = 10;
Soit y = 2;
println!("Sum: ", x + y);
println!("Différence: ", x - y);
println!("Product: ", x * y);
println!("Quotient: ", x / y);
println!("Modulo: ", x% y);

Le code ci-dessus doit retourner:

Opérateurs logiques de la rouille

La deuxième catégorie d'opérateurs soutenue par la Rust Lang est les opérateurs logiques. Ces types d'opérateurs sont utilisés pour combiner deux conditions booléennes ou plus. Les opérateurs logiques renverront toujours une valeur booléenne.

Ils comprennent:

Symbole de l'opérateur	Nom de l'opérateur	Description
&&	Court-circuit logique et	Renvoie vrai si toutes les conditions spécifiées évaluent pour être vrai.
||	Court-circuit logique ou	Renvoie vrai si au moins une des conditions spécifiées est vraie.
!	Logique pas	Nie le résultat d'une expression booléenne. Si la condition est vraie, l'opérateur non renvoie faux.

Exemple d'implémentation de code est tel que montré:

fn main ()
// Opérateurs arithmétiques
Soit x = true;
Soit y = false;
println!("Logical et: ", (x && y));
println!("Logique ou: ", (x || y));
println!("Logical Not: ", (!X));
println!("Logical Not: ", (!y));

Le code ci-dessus doit revenir comme:

Opérateurs de comparaison de la rouille

Les opérateurs de comparaison comparent deux opérandes et renvoient une valeur booléenne en fonction de la condition.

Ces opérateurs comprennent:

Symbole de l'opérateur	Nom de l'opérateur	Description
>	Plus grand que	Renvoie vrai si l'opérande de gauche est supérieur à l'opérande droit.
<	Moins que	Renvoie vrai si l'opérande gauche est inférieure à l'opérande droit.
> =	Plus grand ou égal à	Renvoie True si l'opérande gauche est supérieur ou égal à l'opérande droit.
<=	Inférieur ou égal à	Renvoie vrai si l'opérande gauche est inférieur ou égal à l'opérande droit.
==	Égal à	Retour vrai si l'opérande gauche est égal à l'opérande droit.
!=	Pas égal à	Renvoie True si l'opérande gauche n'est pas égal à l'opérande droit.

Nous pouvons illustrer l'utilisation des opérateurs de comparaison, comme indiqué dans le code ci-dessous:

fn main ()
Soit x = 10;
Soit y = 2;
println!("est x supérieur à y: ", (x> y));
println!("est x inférieur à y: ", (x < y));
println!("est x égal à y: ", (x == y));
println!("est x supérieur ou égal à: ", (x> = y));
println!("est x inférieur ou égal à: ", (x <= y));
println!("x n'est pas égal y: ", (x != y));

Le code ci-dessus doit retourner:

Opérateurs de rouille

Les opérateurs à bit sont utilisés pour effectuer des opérations bit. Ils comprennent:

Symbole de l'opérateur	Nom de l'opérateur	Description
&	Dans le monde et	Fonctionne booléen et à chaque bit.
|	Bit ou	Effectuer booléen ou sur chaque bit
^	XOR	Effectue une booléenne exclusive ou sur chaque bit.
!	Bitwise pas	Effectue unary non.
<<	Bithift gauche	déplace l'opérande de bit gauche vers la gauche par le montant spécifié par l'opérande droit.
>>	Bithift droit	Déplace l'opérande gauche par la valeur spécifiée par l'opérande droit.

Un exemple de code source est illustré ci-dessous:

fn main ()
Soit x = 10;
Soit y = 2;
println!("Bitwise et: ", (x & y));
println!("Bitwise ou: ", (x | y));
println!("Bitwise exclusif ou: ", (x ^ y));
println!("Gauche bithift ", (x << y));
println!("BitShift droit: ", (x >> y));
println!("Bitwise Not: ", (!X));

Le code ci-dessus doit renvoyer la sortie comme indiqué:

Bitwise et: 2
Bitwise ou: 10
Exclusivité bitwise ou: 8
Bithift gauche 40
Bithift droit: 2
Bitwise pas: -11

Opérateurs d'attribution de composés de rouille

Les opérateurs d'attribution composés sont utilisés pour attribuer la valeur à droite à la valeur à gauche. Ceux-ci inclus:

Symbole de l'opérateur	Nom de l'opérateur
+=	Ajout et affectation arithmétique
-=	Soustraction et affectation arithmétique
* =	Multiplication et affectation arithmétique
/ =	Division et affectation arithmétique
>> =	Shift à droite et affectation
<<=	Décalage de gauche et affectation
% =	Reste arithmétique et affectation
& =	Bit dans et et affectation
| =	Bit ou affectation
^ =	Exclusivité ou affectation bitwise

Conclusion

Cet article a discuté des opérateurs de rouille et comment nous pouvons les utiliser dans nos programmes. Vérifiez la documentation de la rouille à explorer.

Merci pour la lecture!!