Go语言学习 -- 基础（流程控制语句）

1. for循环

for
Go 只有一种循环结构：for 循环。

基本的 for 循环由三部分组成，它们用分号隔开：

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

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

package main

import "fmt"

func main() {
	sum := 0
	for i := 0; i < 10; i++ {
		sum += i
	}
	fmt.Println(sum)
}

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

func main() {
	sum := 1
	for ; sum < 10; {
		sum += sum
		fmt.Println(sum)
	}
	fmt.Println(sum)
}

2. for 是 Go 中的 “while”

func main() {
	sum := 1
	for sum < 3 {
		sum += sum
	}
	fmt.Println(sum)
}

3. 无限循环

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

package main

func main() {
	for {
	}
}

4. 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))
}

5. if 的简短语句

同 for 一样， if 语句可以在条件表达式前执行一个简单的语句。

该语句声明的变量作用域仅在 if 之内。

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),
	)
}

6. if 和 else

在 if 的简短语句中声明的变量同样可以在任何对应的 else 块中使用。

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),
	)
}

7. 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 ")
	switch os := runtime.GOOS; os {
	case "darwin":
		fmt.Println("OS X.")
	case "linux":
		fmt.Println("Linux.")
	default:
		// freebsd, openbsd,
		// plan9, windows...
		fmt.Printf("%s.\n", os)
	}
}

8. 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.Saturday {
	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.")
	}
}

9. 没有条件的 switch

没有条件的 switch 同 switch true 一样。

这种形式能将一长串 if-then-else 写得更加清晰。

package main

import (
	"fmt"
	"time"
)

func main() {
	t := time.Now()
	switch {
	case t.Hour() < 12:
		fmt.Println("Good morning!")
	case t.Hour() < 17:
		fmt.Println("Good afternoon.")
	default:
		fmt.Println("Good evening.")
	}
}

10. defer

defer 语句会将函数推迟到外层函数返回之后执行。

推迟调用的函数其参数会立即求值，但直到外层函数返回前该函数都不会被调用。

package main

import "fmt"

func main() {
	defer fmt.Println("world")

	fmt.Println("hello")
}

输出：

hello
world

11. defer 栈

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

package main

import "fmt"

func main() {
	fmt.Println("counting")

	for i := 0; i < 10; i++ {
		defer fmt.Println(i)
	}

	fmt.Println("done")
}

12. for range

• 循环遍历的方式

 for i := 0;i < 10;i++{
 }

 i := 0
 for ;i < 10;i++{
 }

for i < 10 {
	i++
}

for {
	if i < 10{
		break
	}
	i++
}

13. for range

• 对于数组 切片 字符串 返回索引和值
• map 返回索引和值
• 通道返回通道内的值

遍历数组 切片

for key, value := range []int{1, 2, 3, 4}{
	fmt.Printf("key : %d value : %d\n", key, value)
}

遍历字符串 – 获得字符

var str = "hello 你好"
for key, value := range str{
	fmt.Println("key : %d value : %c", key, value)
}

遍历map

m := make(map[string]int)
m["hello"] = 100
m["world"] = 200
for key, value := range m {
	fmt.Prinltln(key, value)
}

遍历通道

c := make(chan int)
	go func() {
		c <- 1
		c <- 2
		c <- 3
		close(c)
	}()
	for v := range c  {
		fmt.Println(v)
	}

14. goto

goto标签

单个break 只能跳出一层循环
使用goto 语句可以跳转所有的循环

package main
import "fmt"

func main(){
	for x := 0;x < 10;x++{
		for y := 0;y < 10 ;y++{
			if y == 2 {
				//跳转标签
				goto breakHere
			}
		}
	}
	// 必须要有的return 否则的话即使没有在循环里面中也会打印done
	return 
breakHere:
		fmt.Println(""done)
}

break 跳出指定循环

package main
imoort "fmt"

func main(){
OuterLoop:
	for i := 0;i < 2;i++{
		for j := 0;j < 5;j++{

			switch j{
				case 2:
					fmt.Println(i, j)
					break OuterLoop
				case 3:
					fmt.Println(i, j)
					break OuterLoop
			}
		}
	}
}

continue 结束当前循环 执行下一次循环

package main
import "fmt"

func main(){
OuterLoop:
	for i := 0;i < 2;i++{
		for j := 0;j < 5; j++{
			switch j{
				case 2 :
					fmt.Println(i, j)
					continue OuterLoop
			}
		}
	}
}