最近在看《Programming F#》这本书，大约看到了第二章，感觉还不错，挺适合我这样的初学者。本书目前只有英文版的，以前看英文书很少能认认真真的看下去的，这次到还不错，已经看到了60多页了，目前把第二章看完了，也就是最基础的部分(Fundamentals)，现在打算整理下，也算是对之前学习的内容的复习吧。
数字
这个跟C#里的没什么差别，只是在写法上略有不同。
| 类型 | 后缀 | .Net 类型 | 范围 |
| byte | uy | System.Byte | 0 to 255 |
| sbyte | y | System.SByte | -127 to 128 |
| int16 | s | System.Int16 | −32,768 to 32,767 |
| uint16 | us | System.UInt16 | 0 to 65,535 |
| int, int32 | System.Int32 | −2^31 to 2^31 − 1 | |
| uint, uint32 | u | System.UInt32 | 0 to 2^32 – 1 |
| int64 | L | System.Int64 | -2^63 to 2^63 – 1 |
| uint64 | UL | System.UInt64 | 0 to 2^64 – 1 |
| float* | System.Double | ||
| float32** | f | System.Float | |
| decimal | M | System.Decimal |
* ** 这2个倒是跟C#有些差别，需要注意。测试了下，float也可以写做double;float32可以写作single。
// byte
let n_byte = 2uy
val n_byte : byte = 2uy
// sbyte
let n_sbyte = –3y
val n_sbyte : sbyte = –3y
// int16
let n_int16 = –513s
val n_int16 : int16 = –513s
// uint16
let n_uint16 = 65000us
val n_uint16 : uint16 = 65000us
// int
let n_int = –100323
val n_int : int = –100323
// uint
let n_uint = 2345000
val n_uint : int = 2345000
// int64
let n_int64 = –354533234342L
val n_int64 : int64 = –354533234342L
// uint64
let n_uint64 = 3423454323443UL
val n_uint64 : uint64 = 3423454323443UL
// float
let n_double = 3.14159265358979
val n_double : float = 3.141592654
// float32
let n_single = 1.41414141f
val n_single : float32 = 1.41414142f
// decimal
let n_decimal = 0.6180339887498948482045868344M
val n_decimal : decimal = 0.6180339887498948482045868344M
// bigint
let n_bigint = 12345678901234567890I
val n_bigint : System.Numerics.BigInteger = 12345678901234567890
四则运算
加法：+
减法：-
乘法：*
除法：/
在F#里，运算符的两侧必须是2个相同类型的数字进行运算，不能像C#里那样自动类型转换。例如，当1 + 1.0的时候会得到如下错误：
> let x = 1 + 1.0;;
let x = 1 + 1.0;;
------------^^^
d:\Temp\Max\stdin(5,13): error FS0001: The type 'float' does not match the type 'int'
需要显示的做出类型转换：
> let x = float 1 + 1.0;;
val x : float = 2.0
乘方运算符为：**，例如 2 ** 3 = 8。乘方运算符仅适用于float以及float32类型。
取模运算符为：%， 例如 5 % 3 = 2。
类型转换
下表给出了几种类型转换的例子，其中第一个跟C#里的，基本上形式差不多（sbyte）5，后面3种，是将字符串转换成数字，这个实际上是调用了System.Convert中的方法。当转换失败的时候，则会抛出System.FormatException。
| 类型 | 描述 | 例子 | 结果 |
| sbyte | convert to sbyte | sbyte 5 | 5y |
| byte | convert to byte | byte “42” | 42uy |
| int16 | convert to int16 | int16 ‘a’ | 97s |
| uint64 | convert to uint64 | uint64 “0xFF” | 256UL |
BigInt
BigInt是在.Net 4.0新增加的数据类型，这在计算一些很大的数的时候很有用。它在System.Numerics命名空间下，类型名称是BigInterget。
let gigabyte = 1024I * 1024I * 1024I
let petabyte = gigabyte * 1024I * 1024I;;
val gigabyte : System.Numerics.BigInteger = 1073741824
val petabyte : System.Numerics.BigInteger = 1125899906842624
位运算
| 操作 | 描述 | 例子 | 结果 |
| &&& | 位与 | 0b1111 &&& 0b0011 | 0b0011 |
| ||| | 或与 | 0xFF00 ||| 0x00FF | 0xFFFF |
| ^^^ | 异或 | 0b0011 ^^^ 0b0101 | 0b0110 |
| <<< | 左位移 | 0b0001 <<< 3 | 0b1000 |
| >>> | 右位移 | 0b1000 >>> 3 | 0b0001 |
字符
.Net下的字符表现为2-byte的UTF-16。
printfn "Hex u0061 = '%c'" '\u0061';;
Hex u0061 = 'a'
// convert char to int
int ‘C’;;
val it : int = 67
// convert char to byte
‘C’B;;
val it : byte = 67uy
字符串
在F#里，字符串的定义可以有以下3种方式：
// 普通的定义方式
let password = “abcd”;;
val it : string = “abcd”
// 带换行的定义
let password = “abc
d
e”;;
val it : string = “abc
d
e”
// 除最后一行外，每行最后带'\’，这样可以将一个很长的string拆成多行，但实际还是一行
let password =”abc\
d\
e”;;
val it : string = “abcde”
获取string中的字符的方式也不同于C#，语法是：string.[index]，例如"string”.[0] = ‘s’。
布尔值
true & false
| 操作 | 说明 | 例子 | 结果 |
| && | 与 | true && false | false |
| || | 或 | true || false | true |
| not | 非 | not false | true |
在F#里也是支持布尔运算也是支持短路的（不记得是不是这么叫的了）
true || f() // will return true and won’t execute function f
false && f() // will return false and won’t execute function f
数据比较
| 操作 | 说明 | 例子 | 结果 |
| < | 小于 | 1 < 2 | true |
| <= | 小于等于 | 4.0 <= 4.0 | true |
| > | 大于 | 1 > 2 | false |
| >= | 大于等于 | 4.0 >= 4.0 | true |
| = | 等于 | 3u = 4u | false |
| <> | 不等于 | 3I <> 4I | true |
| compare | 比较 | compare 1 1 | 0 |
| compare 0 1 | -1 | ||
| compare 10 | 1 |
好了，F#里基本的数据类型就差不多介绍完了。后面该介绍在F#里怎么定义方法还有一些核心类型，如Unit, Tuple, Option等之类的了。