1、顺序结构

程序从上到下逐行地执行，中间没有任何判断和跳转。

func main() {
    var num1 int = 10 //声明了 num1
    var num2 int = num1 + 20 //使用 num1 
    fmt.Println(num2)
}

2、选择结构

2.1 if结构

if 条件判断 {  
    代码语句  
}  
条件判断如果为真（true）,那么就执行大括号中的语句，如果为假（false），就不执行大括号中的语句

var age int = 19
if age >= 18 {
    fmt.println("成年了")
}

2.2 if else结构

if 条件判断{  
    代码语句1  
} else {  
    代码语句2  
}  
如果条件判断成立（结果为真），执行代码语句1，否则执行else后面的代码语句2

var age int = 19
if age >= 18 {
    fmt.println("成年了")
} else {
    fmt.println("未成年")
}

2.3 if-else if 结构

if 表达式1 {
    分支1
} else if 表达式2 {
    分支2
} else{
    分支3
}

var score int = 95
if score >= 90 {
    fmt.println("优秀")
} else if score >= 80 {
    fmt.println("良好")
} else if score >= 60 {
    fmt.println("合格")
} else {
    fmt.println("不合格")
}

2.4 switch结构

switch 变量或者表达式的值{
    case 值1:
        要执行的代码
    case 值2:
        要执行的代码
    case 值3:
        要执行的代码
    default:
        要执行的代码
}
程序执行到switch处，首先将变量或者表达式的值计算出来，然后拿着这个值依次跟每个case后面所带的值进行匹配，一旦匹配成功，则执行该case所带的代码，执行完成后，跳出switch-case结构。如果，跟每个case所带的值都不匹配。就看当前这个switch-case结构中是否存在default，如果有default，则执行default中的语句，如果没有default，则该switch-case结构什么都不做。

var score int = 19
switch {//switch 后面省略不写，默认相当于：switch true
    case score >= 90:
        fmt.println("优秀")
    case score >= 80:
        fmt.println("良好")
    case score >= 60:
        fmt.println("合格")
    default:
        fmt.println("不合格")
}
1.Go语言中的 switch 默认给每个 case 自带 break。因此匹配成功后不会向下执行其他的 case 分支，而是跳出整个 switch。可以添加 fallthrough（中文含义是：贯穿），强制执行后面的 case 分支。fallthrough 必须放在 case 分支的最后一行。如果它出现在中间的某个地方，编译器就会报错。
2.case 后的值不能重复，但可以同时测试多个符合条件的值，也就是说 case 后可以有多个值，这些值之间使用逗号分隔，例如：case val1, val2, val3。
3.switch 后的表达式可以省略，默认是 switch true。

switch 语句还可以被用于 type-switch 来判断某个 interface 变量中实际指向的变量类型

func judgeType(x interface{}){
    switch x.(type) {
        switch t := x.(type) {
            case string:
		fmt.Printf("x is a string，value is %v\n", t)
            case int:
		fmt.Printf("x is a int is %v\n", t)
            case bool:
		fmt.Printf("x is a bool is %v\n", t)
            default:
		fmt.Println("unsupport type！")
	}
    }
}

3、循环结构

GO语言中只有for循环结构，没有while,do-while结构
for循环的基本格式如下：

for 初始语句;条件表达式;结束语句{
    循环体语句
}

for循环的初始语句可以被忽略，但是初始语句后的分号必须要写:

for ;条件表达式;结束语句{
    循环体语句
}

for循环的初始语句和结束语句都可以省略

for 条件表达式 {
    循环体语句
}

无限循环

for {
    循环体语句
}

for range

Go语言中可以使用for range遍历数组、切片、字符串、map 及通道（channel）
数组、切片、字符串返回索引和值。
map返回键和值。
通道（channel）只返回通道内的值。

结束循环-break

break 语句用于终止某个语句块的执行，用于中断当前 for  循环或跳出 switch 语句
break语句还可以在语句后面添加标签，跳出某个标签对应的代码块，标签要求必须定义在对应的for、switch 的代码块上
func breakLoop() {
label:
    for i := 0; i < 10; i++ {
        for j := 0; j < 10; j++ {
            if j == 2 {
                break label
            }
                fmt.Printf("%v-%v\n", i, j)
            }
        }
	fmt.Println("...")
}

继续下次循环-continue

continue语句可以结束当前循环，开始下一次的循环，仅限在for循环内使用。
在 continue语句后添加标签时，表示开始标签对应的循环。
func continueLoop() {
label1:
    for i := 0; i < 5; i++ {
        // label2:
               for j := 0; j < 5; j++ {
                   if i == 2 && j == 2 {
                       continue label1
                   }
                   fmt.Printf("%v-%v\n", i, j)
		}
	}
}

跳转到指定标签-goto

goto语句通过标签进行代码间的无条件跳转。
Go 程序设计中一般不主张使用 goto 语句， 以免造成程序流程的混乱
func gotoLabel() {
    for i := 0; i < 10; i++ {
        for j := 0; j < 10; j++ {
            if j == 2 {
                goto label
            }
                fmt.Printf("%v-%v\n", i, j)
        }
    }
    return
label:
    fmt.Println("结束for循环")
}

Go语言基础-流程控制