基本类型
|
类型
|
后缀
|
.NET 类型
|
数值范围
|
|
byte
|
uy
|
System.Byte
|
0 … 255
|
|
sbyte
|
y
|
System.SByte
|
-128 … 127
|
|
int16
|
s
|
System.Int16
|
-32768 … 32767
|
|
uint16
|
us
|
System.UInt16
|
0 … 65535
|
|
int, int32
|
|
System.Int32
|
-231 … 231-1
|
|
uint, uint32
|
u
|
System.UInt32
|
0 … 232−1
|
|
int64
|
L
|
System.Int64
|
-263 … 263-1
|
|
uint64
|
UL
|
System.UInt64
|
0 … 264-1
|
|
float
|
|
System.Double
|
一个基于IEEE64标准的双精度浮点数。表示为约15位有效数字的值。
|
|
float32
|
f
|
System.Float
|
基于IEEE32标准的单精度浮点数。约7位有效数字。
|
|
decimal
|
M
|
System.Decimal
|
具有28位有效数字的固定精度的浮点数。
|
F#可以使用16进制、8进制和2进制来指定值。分别使用前缀0x、0o和0b。
如果熟悉IEEE32和IEEE64标准，也可以直接使用16进制、8进制和2进制来指定浮点数，F#会将它们直接转换为对应的浮点数。当使用不同的进制来表示浮点数时，可以用LF后缀指定类型为float，用lf后缀来指定类型为float32。
|
运算符
|
说明
|
示例
|
结果
|
|
+
|
加法
|
1 + 2
|
3
|
|
-
|
减法
|
1 – 2
|
-1
|
|
*
|
乘法
|
2 * 3
|
6
|
|
/
|
除法
|
8L / 3L
|
2L
|
|
**
|
求幂注
|
2.0 ** 8.0
|
256.0
|
|
%
|
求模
|
7 % 3
|
1
|
注：**操作符只能对float和float32类型使用。要求整型值的幂，必须先把它转换成浮点数或者使用pown函数。
默认情况下，数值操作符是不会检查溢出的，所以必须自己注意整数值的处理范围。
F#支持以下这些标准数学函数：
|
函数
|
说明
|
示例
|
结果
|
|
abs
|
求数的绝对值
|
abs -1.0
|
1.0
|
|
ceil
|
增大到最接近的整数
|
ceil 9.1
|
10
|
|
exp
|
计算e的x次方
|
exp 1.0
|
2.718
|
|
floor
|
减小到最接近的整数
|
floor 9.9
|
9.0
|
|
sign
|
求数字的符号
|
sign -5
|
-1
|
|
log
|
自然对数
|
log 2.71828
|
1.0
|
|
log10
|
10的对数
|
log10 1000.0
|
3.0
|
|
sqrt
|
平方根
|
sqrt 4.0
|
2.0
|
|
cos
|
余弦函数
|
cos 0.0
|
1.0
|
|
sin
|
正弦函数
|
sin 0.0
|
0.0
|
|
tan
|
正切函数
|
tan 1.0
|
1.557
|
|
pown
|
计算整数的幂
|
pown 2L 10
|
1024L
|
|
函数
|
说明
|
示例
|
结果
|
|
sbyte
|
将数据转换成sbyte
|
sbyte -5
|
-5y
|
|
byte
|
将数据转换成byte
|
byte "42"
|
42uy
|
|
int16
|
将数据转换成int16
|
int16 'a'
|
97s
|
|
uin16
|
将数据转换成uint16
|
uint16 5
|
5us
|
|
int32, int
|
将数据转换成int
|
int 2.5
|
2
|
|
uint32, uint
|
将数据转换成uint
|
uint32 0xFF
|
255
|
|
int64
|
将数据转换成int64
|
int64 -8
|
-8L
|
|
uint64
|
将数据转换成int64
|
uint64 "0xFF"
|
255UL
|
|
float
|
将数据转换成float
|
float32 3.14159M
|
3.1415
|
|
float32
|
将数据转换成float32
|
float32 8y
|
8.0f
|
|
decimal
|
将数据转换成decimal
|
decimal 1.23
|
1.23M
|
转换函数接受字符串参数时，内部是调用System.Convert系列方法的，也就是说这些函数接收到非法输入时会抛出System.FormatException异常。
|
操作符
|
说明
|
示例
|
结果
|
|
&&&
|
按位与
|
0b1111 & 0b0011
|
0b0011
|
|
|||
|
按位或
|
0xFF00 ||| 0x00FF
|
0xFFFF
|
|
^^^
|
按位异或
|
0b0011 ^^ 0b0101
|
0b0110
|
|
<<<
|
左移
|
0b0001 <<< 3
|
0b1000
|
|
>>>
|
右移
|
0b1000 >>> 3
|
0b0001
|
-
字符
.NET框架使用Unicode，因此F#的字符也是2字节的UTF-16字符。可以通过将Unicode字符放在单引号中，或者直接使用16进制值来定义字符。
示例：
> let vowels = ['a'; 'e'; 'i'; 'o'; 'u'];;
val vowels : char list = ['a'; 'e'; 'i'; 'o'; 'u']
> printfn "Hex u0061 = '%c'" '\u0061';;
Hex u0061 = 'a'
val it : unit = ()
输入特殊的控制字符需要使用转义符，这跟C/C++流的语言差不多的，使用一个反斜杠加上一个特殊字符的形式。转义字符列表如下：
|
字符
|
含义
|
|
\'
|
单引号
|
|
\"
|
双引号
|
|
\\
|
反斜杠
|
|
\b
|
退格
|
|
\n
|
换行
|
|
\r
|
回车
|
|
\t
|
水平Tab
|
可以使用前面的类型转换函数来将字符转换成对应的Unicode值。
-
字符串
F#中的字符串使用双引号括起来。要访问字符串中的某一个字符，可以使用.[ ]形式的语法。字符索引是以0开始的。如：
> let password = "abracadabra";;
val password : string = "abracadabra"
> let multiline = "This string
takes up
multiple lines";;
val multiline : string = "This string
takes up
multiple lines";;
> multiline.[0];;
val it : char = 'T'
> multiline.[1];;
val it : char = 'h'
> multiline.[2];;
val it : char = 'i'
> multiline.[3];;
val it : char = 's'
如果字符串比较长，在一行中书写出来影响可读性，可以在行的末尾使用一个反斜杠。最后处理时，将把反斜杠之后的一行移除前面的空白之后添加到前一行上。
let longString = "abc-\
def-\
ghi";;
> longString;;
val it : string = "abc-def-ghi"
当需要指定的文本含有很多转义字符时，如定义文件路径或者注册表值，可以在字符串之前加上一个@号。这时F#不会对后面的字符串内容进行转义操作。
在字符串定义后加上B后缀，得到的不是字符串本身，而是包含字符串中所有字符的字节数组。
-
布尔值
F#的布尔值有true和false两个值，该类型实际就是.NET的System.Boolean类型。操作符有下面几个：
|
操作符
|
说明
|
示例
|
结果
|
|
&&
|
布尔与
|
true && false
|
false
|
|
||
|
布尔或
|
true && false
|
true
|
|
not
|
布尔非
|
not false
|
true
|
下面是一个示例，printTruthTable函数具有一个名为f的参数，用来打印布尔操作的结果。
> // Print the truth table for the given function
let printTruthTable f =
printfn " |true | false |"
printfn " +-------+-------+"
printfn " true | %5b | %5b |" (f true true) (f true false)
printfn " false | %5b | %5b |" (f false true) (f false false)
printfn " +-------+-------+"
printfn ""
();;
val printTruthTable : (bool -> bool -> bool) -> unit
> printTruthTable (&&);;
|true | false |
+-------+-------+
true | true | false |
false | false | false |
+-------+-------+
val it : unit = ()
> printTruthTable (||);;
|true | false |
+-------+-------+
true | true | true |
false | true | false |
+-------+-------+
val it : unit = ()
从这个例子可以发现F#一些有趣的特性，操作符居然也可以作为函数参数来传递。这一点有时候会非常方便，可以在运行时再决定运算的类型。我还是第一次在某个编程语言中发现这样的特性。从这里也可以看出，F#内部实现中将运算符也是作为函数来处理的，可谓是"函数化"得相当彻底啊，呵呵。
F#的布尔表达式处理延续了C/C++系列语言的方式，当表达式中的前一个部分求值之后已经可以决定整个表达式的值时，就不会再对下一个表达式求值。例如true || f()这个表达式，永远不会调用f()函数求值。
|
操作符
|
说明
|
示例
|
结果
|
|
<
|
小于
|
1 < 2
|
true
|
|
<=
|
小于等于
|
4.0 <= 4.0
|
true
|
|
>
|
大于
|
1.4e3 > 1.0e2
|
true
|
|
>=
|
大于等于
|
0I >= 2I
|
false
|
|
=
|
等于
|
"abc" = "abc"
|
true
|
|
<>
|
不等于
|
'a' <> 'b'
|
true
|
|
compare
|
比较两个值
|
compare 31 31
|
0
|