F#入门学习（七）

1. mutable可变值关键字
   F#这个语言与其他入门语言有个很大的不同，那就是，定义的值是不可变的。
   也就是说，默认情况下，系统自动认为值是不可变的。
   
   这样的两行代码在C语言可行，在F#中却说x的定义重复。
   不可变值有很多优点：

• 内在的线程安全
• 在推理和理解方面较简单
• 有较高的安全性
  但是如果必须用到可变的值呢？
  就可以使用mutable关键字了。

  let mutable x = 5
  x
  x <- 10
  x
  

  //val mutable x : int = 5代表x可变
  //val it : int = 5现在x值为5
  //val mutable x : int = 10现在x这个可变关键字被赋值为10
  //val it : int = 10现在x值为10
  <- 这个运算符的功能是将值赋值给已定义标识符
  mutable 与 <- 要一起出现

2. if条件表达式（if … then …else…)
   then和else返回值必须相同

   let x = 56
   let msg = 
       if x = 56 then "是56"
       else "不是56"
   

   //val x : int = 56
   //val msg : string = “是56”
   这是最普通的一种表达

   let test x y = 
       if x = y then  "等于"
       elif x<y then "小于"
       else "大于"
   printfn "%d %s %d."10 (test 10 20) 20
   //这里的（test 10 20）必须加括号，代表是string类型，要不然会报错。
   

   //10 小于 20.
   //val test : x:'a -> y:'a -> string when 'a : comparison
   //val it : unit = ()
   这些都是完整的if语句，那要是语句不完整，会出现什么情况？
   
   缺少else是要报错的，原因是if是一个表达式，而非语句，（这句话我读了好几遍还是云里雾里，但是我知道）后面可以跟（printf语句，或者<- 运算符），就是unit类型，就不会报错。

   let x1 = 1
   if 10 > 20 then printfn"哇哦"
   

   //val x1 : int = 1
   //val it : unit = () unit是if语句默认的类型

   let x1 = 1
   if 30 > 20 then printfn"哇哦"
   

   //哇哦 ( print语句也是unit类型，所以可以运行吗，不会报错。)
   //val x1 : int = 1
   //val it : unit = ()

3. 递归
   这里递归必须要用关键字rec。递归由两部分组成：1.递归出口2.递归体。
   以下是求阶乘的例子：

   let rec fact x = 
       if x = 1 then 1 
       else x * fact(x-1)
   let y = fact 5
   

   //val fact : x:int -> int
   //val y : int = 120
   以下是求和公式：

   let rec sum  x =
       if x = 0 then 0
       else sum(x-1) + x
   let y = sum 100
   

   //val sum : x:int -> int
   //val y : int = 5050

4. 循环表达式(for…to…do…)
   for循环最后返回值必须是unit类型
   以下是1到10求和：

   let mutable s = 0
   for i = 1 to 10 do
       s <- s + i     //<-和mutable对应
       printf"%d "i
   printfn"s = %d"s
   

   //1 2 3 4 5 6 7 8 9 10 s = 55
   //val mutable s : int = 55
   //val it : unit = ()
   以下是打印10到1：

   let fun1 = 			//将for循环封装成一个函数
       for i = 10 downto 1 do
           printf"%d "i
       printfn""
   fun1			//调用
   

   //10 9 8 7 6 5 4 3 2 1
   //val fun1 : unit = ()
   //val it : unit = ()
   以下是使用函数表示起始值和终值：

   let beginning x y = x - 2 * y
   let ending x y = x + 2 * y
   let function3 x y =
       for i = (beginning x y ) to (ending x y) do  	//加括号
           printf"%d "i
       printfn""
   function3 10 4
   

   //2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
   //val beginning : x:int -> y:int -> int
   //val ending : x:int -> y:int -> int
   //val function3 : x:int -> y:int -> unit
   //val it : unit = ()

5. while…do循环表达式（while…do…)
   以下是构造1到10的循环：

   let fun1 = 
       let mutable i = 1
       while i <= 10 do
           printf"%d "i 
           i <- i + 1
       printfn""
   fun1 
   

   //1 2 3 4 5 6 7 8 9 10
   //val fun1 : unit = ()
   //val it : unit = ()

6. 生成随机数，使用while循环生成随机数，直到这个这个随机数等于我们固定好的数

   open System
   let lookForValue value maxValue = 			//想找value,随机数最大能到maxValue
       let mutable contimueLooping = true 		//控制循环条件
       let randomNumbleGenerator = new Random()    //生成一个实例，以后用这个实例干活
       while contimueLooping do 					//while循环，生成1到maxValue之间的随机数
           let rand = randomNumbleGenerator.Next(maxValue)  //这个函数看下图，生成一个非负且不大于maxValue的整数
           printf"%d "rand			//打印每个随机数
           if rand = value then 		//如果找到
               printfn"\n找到数据 %d " value   //就打印找到
               contimueLooping <- false		//并且停止循环
   lookForValue 12 29   	//1到29生成随机数，找12
   

   //17 28 5 15 17 17 2 9 23 7 20 1 10 1 7 7 4 0 2 28 14 9 16 23 1 14 23 6 10 24 17 25 22 28 6 0 8 1 5 17 0 27 0 19 21 21 25 28 12
   //找到数据 12
   //val lookForValue : value:int -> maxValue:int -> unit
   //val it : unit = ()