F＃运算符

2018-12-14 18:12 更新

运算符是一个符号，通知编译器执行特定的数学或逻辑操作。 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

以上内容是否对您有帮助：

← F＃变量

F＃决策 →

写笔记

我要补充