一.分支结构

也就是 if else ，和 .Net 的语法一样（多了强制规范规则）

if condition1 {
    // do something
} else if condition2 {
    // do something else
}else {
    // catch-all or default
}

关键字 if 和 else 之后的左大括号 { 必须和关键字在同一行，如果你使用了 else if 结构，则前段代码块的右大括号 } 必须和 else if 关键字在同一行，这两条规则都是被编译器强制规定的。

 

特殊写法：

if 还有一种特殊的写法，可以在 if 表达式之前添加一个执行语句，再根据变量值进行判断，代码如下：

if err := Connect(); err != nil {
    fmt.Println(err)
    return
}

Connect 是一个带有返回值的函数，err:=Connect() 是一个语句，执行 Connect 后，将错误保存到 err 变量中。

err != nil 才是 if 的判断表达式，当 err 不为空时，打印错误并返回。

这种写法可以将返回值与判断放在一行进行处理，而且返回值的作用范围被限制在 if、else 语句组合中。

 

二.循环结构

也就是 for 循环，不过写法略多

基础写法：

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

简化写法，并可很好支持无限循环，不需要用其他语言 while 等的写法：

sum := 0
for {
    sum++
    if sum > 100 {
        break
    }
}

使用循环语句时，需要注意 左花括号 { 必须与 for 处于同一行

 

Go语言的 for 循环同样支持 continue 和 break 来控制循环，但是它提供了一个更高级的 break，可以选择中断哪一个循环，如下例：

for j := 0; j < 5; j++ {
    for i := 0; i < 10; i++ { if i > 5 {
            break JLoop
        }
        fmt.Println(i)
    }
}
JLoop:
// ...

 

 

三.键值循环 for range

for range 可以遍历数组、切片、字符串、map 及通道（channel），for range 语法上类似于其它语言中的 foreach 语句，一般形式为：

for key, val := range coll {
    ...
}

 

1.遍历字符串——获得字符
key 和 value 分别代表字符串的索引和字符串中的每一个字符

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

 

2.遍历 map——获得 map 的键和值
key 和 value 分别代表 map 的索引键 key 和索引对应的值

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

 

3.遍历通道（channel）——接收通道数据
通道在遍历时，只输出一个值，即管道内的类型对应的数据

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

 

需要要注意的是，val 始终为集合中对应索引的值拷贝，因此它一般只具有只读性质，对它所做的任何修改都不会影响到集合中原有的值。

 

四.switch case语句

Go语言改进了 switch 的语法设计，case 与 case 之间是独立的代码块，不需要通过 break 语句跳出当前 case 代码块以避免执行到下一行

var a = "hello"
switch a {
case "hello":
    fmt.Println(1)
case "world":
    fmt.Println(2)
default:
    fmt.Println(0)
}

 

当出现多个 case 要放在一起的时候，可以写成下面这样

var a = "mum"
switch a {
case "mum", "daddy":
    fmt.Println("family")
}

 

case 后不仅仅只是常量，还可以和 if 一样添加表达式

var r int = 11
switch {
case r > 10 && r < 20:
    fmt.Println(r)
}

 

跨越 case 的 fallthrough，换句话来说，添加关键字后，会继续执行下面符合条件的 case

var s = "hello"
switch {
case s == "hello":
    fmt.Println("hello")
    fallthrough
case s != "world":
    fmt.Println("world")
}

 

 

五.goto语句——跳转到指定的标签

Go语言中 goto 语句通过标签进行代码间的无条件跳转，同时 goto 语句在快速跳出循环、避免重复退出上也有一定的帮助，使用 goto 语句能简化一些代码的实现过程。

  err := firstCheckError()
    if err != nil {
        goto onExit
    }
    err = secondCheckError()
    if err != nil {
        goto onExit
    }
    fmt.Println("done")
    return
onExit:
    fmt.Println(err)
    exitProcess()

可以看出，goto 对应的标签可以看成是一个函数体

 

六.continue语句（继续下一次循环）

Go语言中 continue 语句可以结束当前循环，开始下一次的循环迭代过程，仅限在 for 循环内使用，在 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
            }
        }
    }
}