GO语言----流程控制语句：for、if、else、switch 和 defer

1.for

• Go 只有一种循环结构：for 循环。
  基本的 for 循环由三部分组成，它们用分号隔开：
  初始化语句：在第一次迭代前执行
  条件表达式：在每次迭代前求值
  后置语句：在每次迭代的结尾执行
  初始化语句通常为一句短变量声明，该变量声明仅在 for 语句的作用域中可见。
  一旦条件表达式的布尔值为 false，循环迭代就会终止。
  注意：和 C、Java、JavaScript 之类的语言不同，Go 的 for 语句后面的三个构成部分外没有小括号， 大括号 { } 则是必须的。

package main
import "fmt"
func main() {
    sum := 0for i := 0; i < 10; i++ {
         ##注意规范，for 后面是没有小括号的sum += i}fmt.Println(sum)
}答案:45

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

package main
import "fmt"
func main() {
    sum := 1for ; sum < 1000; {
    sum += sum    ##相当于2sum}fmt.Println(sum)
}答案：1024

• for 是 Go 中的 “while”
  此时你可以去掉分号，因为 C 的 while 在 Go 中叫做 for。

package main
import "fmt"
func main() {
    sum := 1for sum < 1000 {
         ##去掉;相当于whilesum += sum}fmt.Println(sum)
}

• 无限循环
  如果省略循环条件，该循环就不会结束，因此无限循环可以写得很紧凑。

package main
func main() {
    for {
    }
}

• 打印一个矩形

package main
import "fmt"
func main() {
    for i := 1; i<=16; i++ {
    fmt.Print("*")if i%4==0 {
    fmt.Println("")}}
}
//答案：****************

• for的循环嵌套

package mainimport "fmt"
var row =3
var col =4
func main() {
    for i := 1; i<=row; i++ {
    for j :=1;j<=col ; j++ {
    fmt.Print("*")}fmt.Println("")}
}
// 答案：************

• 打印三角形

package mainimport "fmt"
var row =3
func main() {
    for i := 1; i<=row; i++ {
    for j :=1;j<=i ; j++ {
    fmt.Print("*")}fmt.Println("")}
}
//答案：******

• 九九乘法表

package main
import "fmt"
func main() {
    for i :=1;i<=9;i++ {
    for j :=1;j<=i;j++ {
    //fmt.Print(i,"*",j,"=",i*j)//fmt.Print(" ")fmt.Printf("%d*%d=%v \t",i,j,i*j)}fmt.Println("")}
}
//答案：
1*1=1 	
2*1=2 	2*2=4 	
3*1=3 	3*2=6 	3*3=9 	
4*1=4 	4*2=8 	4*3=12 	4*4=16 	
5*1=5 	5*2=10 	5*3=15 	5*4=20 	5*5=25 	
6*1=6 	6*2=12 	6*3=18 	6*4=24 	6*5=30 	6*6=36 	
7*1=7 	7*2=14 	7*3=21 	7*4=28 	7*5=35 	7*6=42 	7*7=49 	
8*1=8 	8*2=16 	8*3=24 	8*4=32 	8*5=40 	8*6=48 	8*7=56 	8*8=64 	
9*1=9 	9*2=18 	9*3=27 	9*4=36 	9*5=45 	9*6=54 	9*7=63 	9*8=72 	9*9=81

• for range用法

//string
package main
import "fmt"
func main() {
    var str	 = "你好golang！"for k,v := range str {
    fmt.Printf("k:%v v:%c \n",k,v)   //%c显示汉字}
}
//答案
k:0  v:你 
k:3  v:好 
k:6  v:g 
k:7  v:o 
k:8  v:l 
k:9  v:a 
k:10  v:n 
k:11  v:g 
k:12  v:！ //切片
package main
import "fmt"
func main() {
    var arr = []string{
    "java","k8s","python","golang"}for i :=0;i< len(arr);i++ {
    fmt.Println(arr[i])}
}
//答案：javak8spythongolang//range进行切片
package main
import ("fmt"
)
func main() {
    var arr = []string{
    "java","k8s","python","golang"}for _,val := range arr {
    fmt.Println(val)   //自动换行}
}
//答案：javak8spythongolang

2.if

• Go 的 if 语句与 for 循环类似，表达式外无需小括号 ( ) ，而大括号 { } 则是必须的。

package main
import ("fmt""math"
)
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

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

package main
import ("fmt""math"
)
func pow(x, n, lim float64) float64 {
    if v := math.Pow(x, n); v < lim {
    return v}return lim
}
func main() {
    fmt.Println(pow(3, 2, 10),pow(3, 3, 20),)
}答案：9  20

• if 和 else
  在 if 的简短语句中声明的变量同样可以在任何对应的 else 块中使用。
  （在 main 的 fmt.Println 调用开始前，两次对 pow 的调用均已执行并返回其各自的结果。）

package main
import ("fmt""math"
)
func pow(x, n, lim float64) float64 {
    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(pow(3, 2, 10),pow(3, 3, 20),)
}
答案：27 >= 209 20

3.switch

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

• runtime 调度器是个非常有用的东西，关于 runtime 包几个方法:
  Gosched：让当前线程让出 cpu 以让其它线程运行,它不会挂起当前线程，因此当前线程未来会继续执行
  NumCPU：返回当前系统的 CPU 核数量
  GOMAXPROCS：设置最大的可同时使用的 CPU 核数
  Goexit：退出当前 goroutine(但是defer语句会照常执行)
  NumGoroutine：返回正在执行和排队的任务总数
  GOOS：目标操作系统

package main
import ("fmt""runtime"
)
func main() {
    fmt.Print("Go runs on ")//var os = runtime.GOOS;//os := runtime.GOOS; ##单独写和在switch后面写都可以switch os := runtime.GOOS; os {
    case "darwin","linux":    //一个分支可以有多个值fmt.Println("OS X.")//break 可写可不写，不会发生穿透case "linux":fmt.Println("Linux.")default:// freebsd, openbsd,// plan9, windows...fmt.Printf("%s.\n", os)}
}//答案：Go runs on Linux.

• switch 的求值顺序
  switch 的 case 语句从上到下顺次执行，直到匹配成功时停止。
  （例如，
  switch i {
  case 0:
  case f():
  }
  在 i==0 时 f 不会被调用。）

package main
import ("fmt""time"
)
func main() {
    fmt.Println("When's Saturday?")today := time.Now().Weekday()      ##显示周几switch time.Friday {
    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 ("fmt""time"
)
func main() {
    t := time.Now()fmt.Println(t)switch {
        //分支后面可以使用表达式，但是sswitch后面不需要跟判断变量case t.Hour() < 12:fmt.Println("Good morning!")case t.Hour() < 17:fmt.Println("Good afternoon.")default:fmt.Println("Good evening.")}
}

• seitch穿透语句fallthrought
  fallthrought语法可以执行 满足条件的case的下一个case，但是只能穿透一层。

package main
import ("fmt"
)
func main() {
    var os = "darwin";switch  os {
    case "darwin":fmt.Println("OS X.")fallthrough    //只能穿透一层，穿透基本用不着case "linux":fmt.Println("Linux.")case "redhat":fmt.Println("redhat.")default:// freebsd, openbsd,// plan9, windows...fmt.Printf("%s.\n", os)}
}
//答案：OS X.Linux.

4.defer

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

package main
import "fmt"
func main() {
    defer fmt.Println("world")fmt.Println("hello")
}
//答案：helloworld

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

package main
import "fmt"
func main() {
    fmt.Println("counting")for i := 0; i < 10; i++ {
    defer fmt.Println(i)}fmt.Println("done")
}
//答案：countingdone9876543210

5.break、continue、goto

5.1 break

• 用于循环语句中跳出当前循环，继续执行循环之后的语句
• 在switch中的case语句中起着每一个case语句执行之后跳出case语句的作用
• 在多重循环中，可以用标号label标出想break 的循环

package main
import "fmt"
func main() {
    
label1:     //写一个label标签，名字随便起for i :=1;i<=7;i++ {
    for j := 1;j<=7;j++ {
    if j==3 {
    break label1     //break直接跳出整个label包含的循环}fmt.Printf("i=%v j=%v \n",i,j)}}
}

5.2 continue

• 结束当前循环，开始下一次循环的迭代，仅限for循环内使用(第一个代码)
• continue和label的配合使用(第二个代码)，continue后面加label标签，表示开始标签对应的循环。

package main
import "fmt"
func main() {
    
//abc:
for i :=1;i<=2;i++ {
    for j := 1;j<=4;j++ {
    if j==3 {
    continue//break abc}fmt.Printf("i=%v j=%v \n",i,j)}
}
}
//答案：
i=1  j=1 
i=1  j=2 
i=1  j=4 
i=2  j=1 
i=2  j=2 
i=2  j=4 

package main
import "fmt"
func main() {
    
label1:for i :=1;i<=2;i++ {
    for j := 1;j<=4;j++ {
    if j==3 {
    continue label1//break abc}fmt.Printf("i=%v j=%v \n",i,j)}}
}
//答案:
i=1  j=1 
i=1  j=2 
i=2  j=1 
i=2  j=2 

5.3 goto(跳转到指定标签)

• goto语句通过标签进行代码间的无条件跳转，goto语句可以在快速跳出循环、避免重复退出上有一定的帮助，使用goto语句可以简化代码。

package main
import "fmt"
func main() {
    var n =30if n>18 {
    fmt.Println("成年了")goto label1}fmt.Println("aaa")fmt.Println("bbb")
label1:fmt.Println("ccc")
}
//答案：
成年了
ccc

6.练习：循环与函数

为了练习函数与循环，我们来实现一个平方根函数：用牛顿法实现平方根函数。

计算机通常使用循环来计算 x 的平方根。从某个猜测的值 z 开始，我们可以根据 z? 与 x 的近似度来调整 z，产生一个更好的猜测：

z -= (zz - x) / (2z)
重复调整的过程，猜测的结果会越来越精确，得到的答案也会尽可能接近实际的平方根。

在提供的 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 {
    z := 1.0// 定义一个初始值并对它初始化temp := 0.0// 临时变量，作为记录z 上次的值for {
      z = z - (z*z-x)/(2*z)// 计算出最新的z值fmt.Println(z)if math.Abs(z-temp) < 0.000000000000001 {
    break// 当值停止改变（或改变非常小）的时候退出循环} else {
    temp = z//　赋值最终的结果}}return z
}func main() {
    fmt.Println(Sqrt(2))
}
//答案：1.51.41666666666666671.41421568627450991.41421356237468991.41421356237309511.4142135623730951.414213562373095