F # - Opérateurs
Un opérateur est un symbole qui indique au compilateur d'effectuer des manipulations mathématiques ou logiques spécifiques. F # est riche en opérateurs intégrés et fournit les types d'opérateurs suivants -
- Opérateurs arithmétiques
- Opérateurs de comparaison
- Opérateurs booléens
- Opérateurs au niveau du bit
Opérateurs arithmétiques
Le tableau suivant montre tous les opérateurs arithmétiques pris en charge par le langage F #. Supposons que la variable A vaut 10 et la variable B 20 alors -
| Opérateur | La description | Exemple |
|---|---|---|
| + | Ajoute deux opérandes | A + B donnera 30 |
| - | Soustrait le deuxième opérande du premier | A - B donnera -10 |
| * | Multiplie les deux opérandes | A * B donnera 200 |
| / | Divise le numérateur par le dénumérateur | B / A donnera 2 |
| % | Opérateur de module et reste après une division entière | B% A donnera 0 |
| ** | Opérateur d'exponentiation, élève un opérande à la puissance d'un autre | B ** A donnera 20 10 |
Opérateurs de comparaison
Le tableau suivant montre tous les opérateurs de comparaison pris en charge par le langage F #. Ces opérateurs de comparaison binaire sont disponibles pour les types intégraux et à virgule flottante. Ces opérateurs renvoient des valeurs de type bool.
Supposons que la variable A vaut 10 et la variable B 20, alors -
| Opérateur | La description | Exemple |
|---|---|---|
| = | Vérifie si les valeurs de deux opérandes sont égales ou non, si oui, la condition devient vraie. | (A == B) n'est pas vrai. |
| <> | Vérifie si les valeurs de deux opérandes sont égales ou non, si les valeurs ne sont pas égales, la condition devient vraie. | (A <> B) est vrai. |
| > | Vérifie si la valeur de l'opérande gauche est supérieure à la valeur de l'opérande droit, si oui, la condition devient vraie. | (A> B) n'est pas vrai. |
| < | Vérifie si la valeur de l'opérande gauche est inférieure à la valeur de l'opérande droit, si oui, la condition devient vraie. | (A <B) est vrai. |
| > = | Vérifie si la valeur de l'opérande gauche est supérieure ou égale à la valeur de l'opérande droit, si oui, la condition devient vraie. | (A> = B) n'est pas vrai. |
| <= | Vérifie si la valeur de l'opérande gauche est inférieure ou égale à la valeur de l'opérande droit, si oui, la condition devient vraie. | (A <= B) est vrai. |
Opérateurs booléens
Le tableau suivant montre tous les opérateurs booléens pris en charge par le langage F #. Supposons que la variable A soit maintenuetrue et la variable B tient false, puis -
| Opérateur | La description | Exemple |
|---|---|---|
| && | Appelé opérateur booléen AND. Si les deux opérandes sont différents de zéro, la condition devient vraie. | (A && B) est faux. |
| || | Opérateur OR booléen appelé. Si l'un des deux opérandes est différent de zéro, la condition devient vraie. | (A || B) est vrai. |
| ne pas | Opérateur booléen appelé NOT. Utilisez pour inverser l'état logique de son opérande. Si une condition est vraie, l'opérateur logique NOT rendra faux. | not (A && B) est vrai. |
Opérateurs au niveau du bit
Les opérateurs au niveau du bit travaillent sur les bits et effectuent des opérations bit par bit. Les tables de vérité pour &&& (AND bit à bit), ||| (OR au niveau du bit) et ^^^ (OR exclusif au niveau du bit) sont les suivants -
| p | q | p &&& q | p ||| q | p ^^^ q |
| 0 | 0 | 0 | 0 | 0 |
| 0 | 1 | 0 | 1 | 1 |
| 1 | 1 | 1 | 1 | 0 |
| 1 | 0 | 0 | 1 | 1 |
Supposons que A = 60; et B = 13; maintenant au format binaire, ils seront comme suit -
A = 0011 1100
B = 0000 1101
-----------------A &&& B = 0000 1100
A ||| B = 0011 1101
A ^^^ B = 0011 0001
~~~ A = 1100 0011
Les opérateurs Bitwise pris en charge par le langage F # sont répertoriés dans le tableau suivant. Supposons que la variable A a 60 et la variable B 13, alors -
| Opérateur | La description | Exemple |
|---|---|---|
| &&& | L'opérateur binaire AND copie un bit dans le résultat s'il existe dans les deux opérandes. | (A &&& B) donnera 12, soit 0000 1100 |
| ||| | L'opérateur OR binaire copie un bit s'il existe dans l'un ou l'autre des opérandes. | (A ||| B) donnera 61, soit 0011 1101 |
| ^^^ | L'opérateur XOR binaire copie le bit s'il est défini dans un opérande mais pas dans les deux. | (A ^^^ B) donnera 49, soit 0011 0001 |
| ~~~ | L'opérateur de complément Binary Ones est unaire et a pour effet de «retourner» les bits. | (~~~ A) donnera -61, soit 1100 0011 sous la forme du complément à 2. |
| <<< | Opérateur de décalage binaire gauche. La valeur des opérandes de gauche est déplacée vers la gauche du nombre de bits spécifié par l'opérande de droite. | Un <<< 2 donnera 240 soit 1111 0000 |
| >>> | Opérateur de décalage binaire vers la droite. La valeur des opérandes de gauche est déplacée vers la droite du nombre de bits spécifié par l'opérande de droite. | Un >>> 2 donnera 15 qui est 0000 1111 |
Priorité des opérateurs
Le tableau suivant montre l'ordre de priorité des opérateurs et autres mots-clés d'expression dans le langage F #, de la priorité la plus basse à la priorité la plus élevée.
| Opérateur | Associativité |
|---|---|
| comme | Droite |
| quand | Droite |
| | (tuyau) | La gauche |
| ; | Droite |
| laisser | Non associatif |
| fonction, amusement, match, essayez | Non associatif |
| si | Non associatif |
| → | Droite |
| : = | Droite |
| , | Non associatif |
| ou, || | La gauche |
| &, && | La gauche |
| <op,> op, =, | op, & op | La gauche |
| &&&, |||, ^^^, ~~~, <<<, >>> | La gauche |
| ^ op | Droite |
| :: | Droite |
| :?>,:? | Non associatif |
| - op, + op, (binaire) | La gauche |
| * op, / op,% op | La gauche |
| ** op | Droite |
| fx (application de fonction) | La gauche |
| | (correspondance de motif) | Droite |
| opérateurs de préfixe (+ op, -op,%, %%, &, &&,! op, ~ op) | La gauche |
| . | La gauche |
| f (x) | La gauche |
| f <types> | La gauche |