NetRoc's Blog

N-Tech

 

F#学习笔记之二 — 数据类型

NetRoc 2010.5.16

http://www.DbgTech.net/

 

  • F#是一个静态类型的语言,即所有类型都在编译时就确定。F#支持.NET库中的所有类型。
  • 基本类型
    • 数值类型。数值类型包括整数和浮点数。

      使用let语句可以定义新的数值。可以带一个可选得后缀来标明数值类型。如:

      let u64SomeVal = 123UL;;

      let pi = 3.1415926M;;

      等等

      数值类型有以下这些:

    类型

    后缀

    .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。

    • 算术运算

      对数值类型可以使用所有的标准算术运算符,和所有CLR语言一样,整数的除法会取最小的商并且忽略余数。

      完整的算术运算符如下表:

    运算符

    说明

    示例

    结果

    +

    加法

    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

    • F#语言设计的一个原则是不进行数据类型的隐式转换,编译器不会在处理时自动转换基本数据类型,这样可以避免因为某些转换造成奇怪的BUG。必须使用下表中的转换函数进行明确的类型转换。这些标准转换函数接受任何其他基本类型的值作为参数 — 包括字符串和字符。

    函数

    说明

    示例

    结果

    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异常。

    • 大整数BigInt

      如果要处理大于264的数字,在F#中可以使用BigInt类型来表示它们。BigInt类型是System.Numerics.BigInteger的别名。但是,在其他.NET语言,如VB.NET和C#中都没有语法来直接支持任意的大整数。

      BigInt使用大写字母I作为后缀。如let BigInt = 313213131321I;;

    • 位操作

      F#支持以下这些位操作符:

    操作符

    说明

    示例

    结果

    &&&

    按位与

    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()函数求值。

    • 比较

      F#中可以使用下面表中列出的操作符来比较值。所有的比较操作符返回的都是布尔值,compare函数返回的是-1、0或者1,分别对应于第一个参数和第二个参数之间是小于、等于或大于的关系。

    操作符

    说明

    示例

    结果

    <

    小于

    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

posted on 2010-05-16 10:00 NetRoc 阅读(566) 评论(0)  编辑 收藏 引用

只有注册用户登录后才能发表评论。

导航

统计

常用链接

留言簿(6)

随笔档案(99)

文章分类(35)

文章档案(32)

Friends

Mirror

搜索

最新评论

阅读排行榜

评论排行榜