F # - Operatoren
Ein Operator ist ein Symbol, das den Compiler anweist, bestimmte mathematische oder logische Manipulationen durchzuführen. F # ist reich an integrierten Operatoren und bietet die folgenden Arten von Operatoren:
- Rechenzeichen
- Vergleichsoperatoren
- Boolesche Operatoren
- Bitweise Operatoren
Rechenzeichen
Die folgende Tabelle zeigt alle von der F # -Sprache unterstützten arithmetischen Operatoren. Angenommen, Variable A hält 10 und Variable B hält 20, dann -
Beispiel zeigen
| Operator | Beschreibung | Beispiel |
|---|---|---|
| + | Fügt zwei Operanden hinzu | A + B ergibt 30 |
| - - | Subtrahiert den zweiten Operanden vom ersten | A - B ergibt -10 |
| * * | Multipliziert beide Operanden | A * B ergibt 200 |
| /. | Teilt den Zähler durch den De-Zähler | B / A ergibt 2 |
| %. | Modul Operator und Rest nach einer ganzzahligen Division | B% A ergibt 0 |
| ** **. | Exponentiation Operator, erhöht einen Operanden auf die Potenz eines anderen | B ** A ergibt 20 10 |
Vergleichsoperatoren
Die folgende Tabelle zeigt alle Vergleichsoperatoren, die von der F # -Sprache unterstützt werden. Diese binären Vergleichsoperatoren sind für Integral- und Gleitkommatypen verfügbar. Diese Operatoren geben Werte vom Typ bool zurück.
Angenommen, Variable A hält 10 und Variable B hält 20, dann -
Beispiel zeigen
| Operator | Beschreibung | Beispiel |
|---|---|---|
| = | Überprüft, ob die Werte von zwei Operanden gleich sind oder nicht. Wenn ja, wird die Bedingung wahr. | (A == B) ist nicht wahr. |
| <> | Überprüft, ob die Werte von zwei Operanden gleich sind oder nicht. Wenn die Werte nicht gleich sind, wird die Bedingung wahr. | (A B) ist wahr. |
| > | Überprüft, ob der Wert des linken Operanden größer als der Wert des rechten Operanden ist. Wenn ja, wird die Bedingung wahr. | (A> B) ist nicht wahr. |
| < | Überprüft, ob der Wert des linken Operanden kleiner als der Wert des rechten Operanden ist. Wenn ja, wird die Bedingung wahr. | (A < B) is true. |
| >= | Checks if the value of left operand is greater than or equal to the value of right operand, if yes then condition becomes true. | (A >= B) is not true. |
| <= | Checks if the value of left operand is less than or equal to the value of right operand, if yes then condition becomes true. | (A <= B) is true. |
Boolean Operators
The following table shows all the Boolean operators supported by F# language. Assume variable A holds true and variable B holds false, then −
Show Example
| Operator | Description | Example |
|---|---|---|
| && | Called Boolean AND operator. If both the operands are non-zero, then condition becomes true. | (A && B) is false. |
| || | Called Boolean OR Operator. If any of the two operands is non-zero, then condition becomes true. | (A || B) is true. |
| not | Called Boolean NOT Operator. Use to reverses the logical state of its operand. If a condition is true then Logical NOT operator will make false. | not (A && B) is true. |
Bitwise Operators
Bitwise operators work on bits and perform bit-by-bit operation. The truth tables for &&& (bitwise AND), ||| (bitwise OR), and ^^^ (bitwise exclusive OR) are as follows −
Show Example
| 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 |
Assume if A = 60; and B = 13; now in binary format they will be as follows −
A = 0011 1100
B = 0000 1101
-----------------A&&&B = 0000 1100
A|||B = 0011 1101
A^^^B = 0011 0001
~~~A = 1100 0011
The Bitwise operators supported by F# language are listed in the following table. Assume variable A holds 60 and variable B holds 13, then −
| Operator | Description | Example |
|---|---|---|
| &&& | Binary AND Operator copies a bit to the result if it exists in both operands. | (A &&& B) will give 12, which is 0000 1100 |
| ||| | Binary OR Operator copies a bit if it exists in either operand. | (A ||| B) will give 61, which is 0011 1101 |
| ^^^ | Binary XOR Operator copies the bit if it is set in one operand but not both. | (A ^^^ B) will give 49, which is 0011 0001 |
| ~~~ | Binary Ones Complement Operator is unary and has the effect of 'flipping' bits. | (~~~A) will give -61, which is 1100 0011 in 2's complement form. |
| <<< | Binary Left Shift Operator. The left operands value is moved left by the number of bits specified by the right operand. | A <<< 2 will give 240 which is 1111 0000 |
| >>> | Binary Right Shift Operator. The left operands value is moved right by the number of bits specified by the right operand. | A >>> 2 will give 15 which is 0000 1111 |
Operators Precedence
The following table shows the order of precedence of operators and other expression keywords in the F# language, from lowest precedence to the highest precedence.
Show Example
| Operator | Associativity |
|---|---|
| as | Right |
| when | Right |
| | (pipe) | Left |
| ; | Right |
| let | Non associative |
| function, fun, match, try | Non associative |
| if | Non associative |
| → | Right |
| := | Right |
| , | Non associative |
| or, || | Left |
| &, && | Left |
| < op, >op, =, |op, &op | Left |
| &&& , |||, ^^^, ~~~, <<<, >>> | Left |
| ^ op | Right |
| :: | Right |
| :?>, :? | Non associative |
| - op, +op, (binary) | Left |
| * op, /op, %op | Left |
| ** op | Right |
| f x (function application) | Left |
| | (pattern match) | Right |
| prefix operators (+op, -op, %, %%, &, &&, !op, ~op) | Left |
| . | Left |
| f(x) | Left |
| f<types> | Left |