UP | HOME

流程控制

Table of Contents

循环

Go 只有一种循环结构―― for 循环

for循环

基本的 for 循环包含三个由分号分开的组成部分：

  1. 初始化语句：在第一次循环执行前被执行
  2. 循环条件表达式：每轮迭代开始前被求值
  3. 后置语句：每轮迭代后被执行

初始化语句一般是一个短变量声明，这里声明的变量仅在整个 for 循环语句可见。如果条件表达式的值变为 false，那么迭代将终止

注意：不像 C，Java，或者 Javascript 等其他语言，for 语句的三个组成部分并不需要用括号括起来，但循环体必须用 { } 括起来！ 

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

简洁for

循环初始化语句和后置语句都是可选的 

sum := 1
for ; sum < 1000; {
        sum += sum
}

while

同样可以省略分号； 这样的for含义和C的while是一样的 

sum := 1
for sum < 1000  {
        sum += sum
}

死循环

省略了循环条件，循环就不会结束，用更简洁地形式表达死循环 

for {
        //infinitly loop 
}

条件

if判断

if语句也不要求用括号将条件括起来，但是{ } 还是必须有的 

if x < 0 {
        return sqrt(-x) + "i"
}
return fmt.Sprint(math.Sqrt(x))

简洁if

if 语句可以在条件之前执行一个简单语句，这个语句定义的变量的作用域仅在if范围之内 

func pow(x, n, lim float64) float64 {
        if v := math.Pow(x, n); v < lim {
                return v
        }
        return lim
}

else语句

在if的便捷语句定义的变量同样可以在任何对应的else块中使用 

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
}

switch判断

注意：除非以 fallthrough 语句结束，否则分支会自动终止 

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

执行顺序

switch 的条件从上到下的执行，当匹配成功的时候停止 

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

无条件switch

没有条件的 switch 同 switch true 一样, 可以用更清晰的形式来编写长的 if-then-else 链 

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

推迟

defer

defer 语句会延迟函数的执行直到上层函数返回。延迟调用的参数会立刻生成，但是在上层函数返回前函数都不会被调用 

func main() {
        //打印world语句被延迟执行
        defer fmt.Println("world")

        fmt.Println("hello")
}

defer栈

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

func main() {
        fmt.Println("counting")
      // counting
      // done
      // 4
      // 3
      // 2
      // 1
      // 0
        for i := 0; i < 5; i++ {
                defer fmt.Println(i)
        }

        fmt.Println("done")
}

Next：复杂类型

Previous：包，函数，变量

Home：目录