Go基础（流程控制语句）：开启Go语言之旅

深藏阁楼爱情的钟 2022-05-24 00:52 279阅读 0赞

## 流程控制语句 ##

Go语言和Java特别相似，包括流程控制语句，主要有以下几种：  
for、if、else、switch、defer。

--------------------

## 一、for ##

**Go 只有一种循环结构：for 循环。**  
基本的 for 循环由三部分组成，它们用分号隔开：

> 初始化语句：在第一次迭代前执行  
> 条件表达式：在每次迭代前求值  
> 后置语句：在每次迭代的结尾执行  
> 初始化语句通常为一句短变量声明，该变量声明仅在 for 语句的作用域中可见。

一旦条件表达式的布尔值为 false，循环迭代就会终止。

*  注意：和 C、Java、JavaScript 之类的语言不同，Go 的 for 语句后面没有小括号，大括号 \{ \} 则是必须的。

### 1.下面来看一个普通for例子 ###

package main
    
    import "fmt"
    
    /** * for后面没有小括号 * i := 0 这个为初始化语句(在第一次迭代前执行) * i < 10 条件表达式(在每次迭代前求值) * i++ 后置语句(在每次迭代的结尾执行) */
    func main() {
        sum := 0
        for i := 0; i <= 10; i++ {
            //下面这个i是指i的初始化值
            //例如i := 9时，i++等于10,sum = 0+1+......+9(注意这里是9而不是10)
            //当i := 10时，i++等于11，sum = 0+1+......+10(注意这里是10而不是11)
            //当i := 11时，就结束了循环
            sum += i
        }
        fmt.Println(sum)
    }

输出语句：

### 2. 再来看一个初始化和后置语句可选的例子 ###

初始化语句和后置语句是可选的。

package main
    
    import "fmt"
    
    func main() {
        sum := 1
    
       //首先sum=1
       //sum = 1 + 1 = 2
       //sum = 2 + 2 = 4
       //sum = 4 + 4 =8
       //sum = 8 + 8 = 16 结束循环
        for ; sum < 10;  {
            sum += sum
           //sum = sum + sum
        }
    
        fmt.Println(sum)
    
       //输出结果16
    }

## 二、for 是 Go 中的 “while” ##

此时你可以去掉分号，因为 C 的 while 在 Go 中叫做 for。  
下面来看一个例子

package main
    
    import "fmt"
    
    func main() {
    
        sum := 1
       //for相当于while
        for sum < 10 {
            sum += sum
        }
        fmt.Println(sum)
    } //输出结果是 16

## 三、无限循环 ##

package main
    
    import "fmt"
    
    func main() {
    
        //一直循环输出10
        for  {
            i := 10
            fmt.Println(i)
        }
    
    }

## 四、if ##

Go的if语句与for循环类似，表达式外无需小括号 ( ) ，而大括号 \{ \} 则是必须的。  
下面写一个开平方根的例子：

package main
    
    import (
        "fmt"
        "math"
    )
    
    /** * math.Sqrt开平方根 */
    func sqrt(x float64) string {
    
        if x < 0 {
            return sqrt(-x) + "i"
        }
    
        return fmt.Sprint(math.Sqrt(x))
    }
    
    func main() {
        fmt.Println(sqrt(2),sqrt(-4))
    }

输出结果：

1.4142135623730951 2i

## 五、if 的简短语句 ##

同 for 一样， if 语句可以在条件表达式前执行一个简单的语句。  
该语句声明的变量作用域仅在 if 之内。（在最后的 return 语句处使用 v 看看。）

package main
    
    import (
        "math"
        "fmt"
    )
    
    func pow(x, n, lim float64)  float64{
    
        //math.Pow返回x**y,计算x的y次方
        if v := math.Pow(x, n); v < lim {
            return v
        }
        return lim
    }
    
    func main() {
        fmt.Println(pow(3, 2, 10))
        fmt.Println(pow(3, 3, 20))
    }

输出结果：

9
    20

## 六、if 和 else ##

在 if 的简短语句中声明的变量同样可以在任何对应的 else 块中使用。  
（在 main 的 fmt.Println 调用开始前，两次对 pow 的调用均已执行并返回。）  
下面来写一个例子：

package main
    
    import (
        "math"
        "fmt"
    )
    
    func ifPow(x, n, lim float64)  float64{
    
        //if后的变量v,可以在if流程控制语句中使用
        //math.Pow(x, n),求x的n次方
        if v := math.Pow(x, n); v < lim {
            return v
        }else {
            fmt.Printf("%g >= %g\n", v, lim)
        }
        //在流程控制语句外，在这里就不能使用v变量
        return lim
    }
    
    func main() {
        fmt.Println(
            ifPow(3,3,20),
            ifPow(3, 2, 10),
        )
    }

输出结果：

27 >= 20 20 9

### 七、循环与函数的练习 ###

为了练习函数与循环，我们来实现一个平方根函数：用牛顿法实现平方根函数。  
计算机通常使用循环来计算 x 的平方根。从某个猜测的值 z 开始，我们可以根据 z² 与 x 的近似度来调整 z，产生一个更好的猜测：  
z -= (z\*z - x) / (2\*z)  
重复调整的过程，猜测的结果会越来越精确，得到的答案也会尽可能接近实际的平方根。  
在提供的 func Sqrt 中实现它。无论输入是什么，对 z 的一个恰当的猜测为 1。 要开始，请重复计算 10 次并随之打印每次的 z 值。观察对于不同的值 x（1、2、3 …）， 你得到的答案是如何逼近结果的，猜测提升的速度有多快。  
提示：用类型转换或浮点数语法来声明并初始化一个浮点数值：  
z := 1.0  
z := float64(1)  
然后，修改循环条件，使得当值停止改变（或改变非常小）的时候退出循环。观察迭代次数大于还是小于 10。 尝试改变 z 的初始猜测，如 x 或 x/2。你的函数结果与标准库中的 math.Sqrt 接近吗？  
（注：如果你对该算法的细节感兴趣，上面的 z² − x 是 z² 到它所要到达的值（即 x）的距离，除以的 2z 为 z² 的导数，我们通过 z² 的变化速度来改变 z 的调整量。这种通用方法叫做牛顿法。它对很多函数，特别是平方根而言非常有效。）  
下面来写一个求平发根的例子：

package main
    
    import (
        "fmt"
        "math"
    )
    
    func Sqrt(x float64) float64 {
        //求平方根
        return math.Sqrt(x)
    }
    
    func main() {
        fmt.Println(Sqrt(2))
    }

输出结果：

1.4142135623730951

## 八、switch ##

switch 是编写一连串 if - else 语句的简便方法。它运行第一个值等于条件表达式的 case 语句。  
Go 的 switch 语句类似于 C、C++、Java、JavaScript 和 PHP 中的，不过 Go 只运行选定的 case，而非之后所有的 case。 实际上，Go 自动提供了在这些语言中每个 case 后面所需的 break 语句。 除非以 fallthrough 语句结束，否则分支会自动终止。 Go 的另一点重要的不同在于 switch 的 case 无需为常量，且取值不必为整数。

package main
    
    import (
        "fmt"
        "runtime"
    )
    
    func main() {
        fmt.Print("Go runs on ")
        //runtime.GOOS 可以获取到现在在什么系统上运行着
        switch os := runtime.GOOS; os {
        case "darwin":
            fmt.Println("OS X.")
        case "linux":
            fmt.Println("Linux.")
        default:
            // freebsd, openbsd,
            // plan9, windows...
            fmt.Printf("%s.", os)
        }
    }

输出结果：

o runs on OS X.

## 九、switch 的求值顺序 ##

switch 的 case 语句从上到下顺次执行，直到匹配成功时停止。  
（例如，

switch i {
    case 0:
    case f():
    }

在 i==0 时 f 不会被调用。）  
*注意：* Go 练习场中的时间总是从 2009-11-10 23:00:00 UTC 开始，该值的意义留给读者去发现。  
下面来写一个求今天是一周中的星期几的例子：

package main
    
    import (
        "fmt"
        "time"
    )
    
    func main() {
        fmt.Println("When`s Saturday?")
        //获取今天是一周中的周几
        today := time.Now().Weekday();
        //time.Sunday 星期天
        switch time.Sunday {
        //如果今天是星期天，那么就输出今天
        case today + 0:
            fmt.Println("Today.")
        case today + 1:
            fmt.Println("Tomorrow.")
        case today + 2:
            fmt.Println("In two days.")
        default:
            fmt.Println("Too far away.")
        }
    }

## 十、没有条件的 switch ##

没有条件的 switch 同 switch true 一样。  
这种形式能将一长串 if-then-else 写得更加清晰。

package main
    
    import (
        "time"
        "fmt"
    )
    
    func main() { //获取现在是几点钟 t := time.Now() //t.Hour()可以打印出现在是多少点，24小时制 println(t.Hour()) switch { case t.Hour() < 12: fmt.Println("Good morning") case t.Hour() < 17: fmt.Println("Good afternoon") default: fmt.Println("Good evening") }
    }

输出结果：

Good evening
    22

## 十一、defer ##

defer 语句会将函数推迟到外层函数返回之后执行。  
推迟调用的函数其参数会立即求值，但直到外层函数返回前该函数都不会被调用。  
下面写一个推迟执行的例子：

package main
    
    import "fmt"
    
    func main() {
        //这个推迟执行了
        defer fmt.Println("world")
        //这个执行完，上面的defer才会执行
        fmt.Println("hello")
    }

输出结果：

hello
    world

## 十二、defer 栈 ##

推迟的函数调用会被压入一个栈中。当外层函数返回时，被推迟的函数会按照后进先出的顺序调用。

package main
    
    import "fmt"
    
    func main() {
        //这个第一个执行
        fmt.Println("counting")
    
        //这个最后一个执行
        for i := 0; i < 10; i++  {
            defer fmt.Println(i)
        }
    
        //这个第二个执行
        fmt.Println("demo")
    }

输出结果：

counting
    demo
    9
    8
    7
    6
    5
    4
    3
    2
    1
    0

好啦，Go语言的流程控制语句在此就结束了。