F＃运算符
运算符是一个符号，通知编译器执行特定的数学或逻辑操作。 F＃拥有丰富的内置操作符，并提供以下类型的操作符
- 算术运算符
- 比较运算符
- 布尔运算符
- 位运算符
算术运算符
下表列出了所有由F＃语言支持的算术运算符。假设变量A持有10和变量B持有20话
| 运算符 | 描述 | 例子 |
|---|---|---|
| + | 再添两个操作数 | A + B will give 30 |
| - | 减去来自第一第二操作数 | A - B will give -10 |
| * | 相乘两个操作数 | A * B will give 200 |
| / | 通过去分子除以分母 | B / A will give 2 |
| ％ | 模运算和整数余数 | B % A will give 0 |
| ** | 指数运算符，将运算符提升为另一个 | B**A will give 20 |
例子
let a : int32 = 21 let b : int32 = 10 let mutable c = a + b printfn "Line 1 - Value of c is %d" c c <- a - b; printfn "Line 2 - Value of c is %d" c c <- a * b; printfn "Line 3 - Value of c is %d" c c <- a / b; printfn "Line 4 - Value of c is %d" c c <- a % b; printfn "Line 5 - Value of c is %d" c
当编译和执行程序时，它会产生以下输出
Line 1 - Value of c is 31 Line 2 - Value of c is 11 Line 3 - Value of c is 210 Line 4 - Value of c is 2 Line 5 - Value of c is 1
比较运算符
下表列出了所有由F＃语言支持的比较运算符。这些二进制比较运算符可用于整数和浮点类型。这些运算符返回布尔类型的值。
假设变量A持有10和变量B持有20，那么
| 运算符 | 描述 | 例 |
|---|---|---|
| = | 检查，如果两个操作数的值相等与否，如果是，则条件变为真。 | （A == B）是不正确的。 |
| <> | 检查，如果两个操作数的值相等与否，如果值不相等，则条件变为真。 | （A <> B）是真实的。 |
| > | 检查左操作数的值大于右操作数的值，如果是，则条件为真。 | （A> B）是不正确的。 |
| < | 检查左操作数的值小于右操作数的值，如果是，则条件为真。 | （A <B）为真。 |
| > = | 检查左操作数的值大于或等于右边的操作数的值，如果是，则条件为真。 | （A> = B）是不正确的。 |
| <= | 检查左操作数的值小于或等于右边的操作数的值，如果是，则条件为真。 | （A <= B）为真。 |
例子
let mutable a : int32 = 21 let mutable b : int32 = 10 if (a = b) then printfn "Line 1 - a is equal to b" else printfn "Line 1 - a is not equal to b" if (a < b) then printfn "Line 2 - a is less than b" else printfn "Line 2 - a is not less than b" if (a > b) then printfn "Line 3 - a is greater than b" else printfn "Line 3 - a is not greater than b" (* Lets change value of a and b *) a <- 5 b <- 20 if (a <= b) then printfn "Line 4 - a is either less than or equal to b" else printfn "Line4 - a is a is greater than b"当编译和执行程序时，将产生以下输出
Line 1 - a is not equal to b Line 2 - a is not less than b Line 3 - a is greater than b Line 4 - a is either less than or equal to b
布尔运算符
下表显示了F＃语言支持的所有布尔运算符。 假设变量A holdstrue和变量B holdfalse，则
| 运算符 | 描述 | 例 |
|---|---|---|
| && | 所谓布尔AND运算。如果两个操作数都非零，则条件变为真。 | （A && B）是假的。 |
| || | 所谓OR运算符。如果任何两个操作数是非零，则条件变为真。 | （A || B）是真实的。 |
| not | 所谓的布尔非操作。使用反转其操作数的逻辑状态。如果条件为真，那么逻辑非运算符将假的。 | 没有（A && B）是真实的。 |
例子
let mutable a : bool = true; let mutable b : bool = true; if ( a && b ) then printfn "Line 1 - Condition is true" else printfn "Line 1 - Condition is not true" if ( a || b ) then printfn "Line 2 - Condition is true" else printfn "Line 2 - Condition is not true" (* lets change the value of a *) a <- false if ( a && b ) then printfn "Line 3 - Condition is true" else printfn "Line 3 - Condition is not true" if ( a || b ) then printfn "Line 4 - Condition is true" else printfn "Line 4 - Condition is not true"
当编译和执行程序时，将产生以下输出
Line 1 - Condition is true Line 2 - Condition is true Line 3 - Condition is not true Line 4 - Condition is true
位运算符
按位运算符处理位并执行逐位操作。 &&&（按位与）的真值表，||| （按位或）和^^^（逐位异或）如下
| 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 |
假设A = 60; 和B = 13; 现在在二进制格式，如下
A = 0011 1100
B = 0000 1101
-----------------
一个&&& B = 0000 1100
一个||| B = 0011 1101
一个^^^ B = 0011 0001
~~~ A = 1100 0011
由F＃语言支持位运算符列于下表。假设变量A持有60和变量B持有13，那么 -
| 运算符 | 描述 | 例 |
|---|---|---|
| &&& | 二进制和运营商副本，如果它存在于两个操作数了一下结果。 | （A &&& B）将给出12，即0000 1100 |
| ||| | 二进制或操作员副本，如果它存在于一个操作数了一下。 | （A ||| B）将给出61，即0011 1101 |
| ^^^ | 二进制XOR算子拷贝如果在一个操作数设置，但不是这两个位。 | （A ^^^ B）将给出49，即0011 0001 |
| ~~~ | 二进制的补运算符是一元的，具有“翻转”位的效果。 | （~~~ A）将给出-61，其是2的补码形式的1100 0011。 |
| <<< | 二进制左移运算。左边的操作数的值被移动通过正确的操作数指定的位数离开了。 | A <<< 2将给出240，即1111 0000 |
| >>> | 二进制右移操作。左边的操作数的值由右操作数指定的位数向右移动。 | A >>> 2将给出15，即0000 1111 |
运算符的优先级
下表显示了F＃语言中运算符和其他表达式关键字的优先级顺序，从最低优先级到最高优先级。
| 运算符 | 关联性 |
|---|---|
| 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 |
let a : int32 = 20 let b : int32 = 10 let c : int32 = 15 let d : int32 = 5 let mutable e : int32 = 0 e <- (a + b) * c / d // ( 30 * 15 ) / 5 printfn "Value of (a + b) * c / d is : %d" e e <- ((a + b) * c) / d // (30 * 15 ) / 5 printfn "Value of ((a + b) * c) / d is : %d" e e <- (a + b) * (c / d) // (30) * (15/5) printfn "Value of (a + b) * (c / d) is : %d" e e <- a + (b * c) / d // 20 + (150/5) printfn "Value of a + (b * c) / d is : %d" e
当编译和执行程序时，将产生以下输出
Value of (a + b) * c / d is : 90 Value of ((a + b) * c) / d is : 90 Value of (a + b) * (c / d) is : 90 Value of a + (b * c) / d is : 50