5.go语言条件语句和循环语句

条件语句

if-else语句

if-else条件语句语法如下，可选语句部分，该组件在条件判断之前运行。go语言规定与 if 匹配的左括号{必须与 if 和表达式放在同一行，与 else 匹配的{也必须与 else 在同一行，else 也必须与上一个 if 或 else if 的右边的大括号在一行。

if 可选语句;条件... {
表达式
} else if 可选语句;条件... {
表达式
} else {
表达式
}

一个条件语句小例子：

package main
import (
"fmt"
)
func main() {
a,b,c := 1,2,3
//在进行条件判断之前会先执行fmt.Println("BEFORE")
if fmt.Println("BEFORE");a > b {
fmt.Println("a > b")
} else if b > c {
fmt.Println("b > c")
} else {
fmt.Println(a,b,c)
}
}

以上语句结果输出：

BEFORE
1 2 3

switch语句

switch语句语法如下，switch 中的每一个 case 与 case 间是独立的代码块，不需要通过 break 语句跳出当前 case 代码块以避免执行到下一行

switch 变量 ｛
case 条件 :
表达式
fallthrough
default:
默认表达式
}

switch语句中case 不允许出现重复项，以下代码会报错duplicate case 2 in switch

package main
import "fmt"
func main() {
a := 3
switch a{
case 1:
fmt.Println(a)
case 2:
fmt.Println(a)
case 3:
fmt.Println(a)
}
}

通过用逗号分隔，可以在一个 case 中包含多个表达式

package main
import "fmt"
func main() {
a := 3
switch a{
case 1,2,3:
fmt.Println(a)
}
}

switch 语句中，表达式是可选的，可以被省略。省略表达式，表示 switch 语句等同于 switch true，每个 case 表达式都被认定为有效，相应的代码块也会被执行

package main
import "fmt"
func main() {
a := 30
switch {//省略表达式，变为switch true，true会和每一个case的结果进行匹配
case a <= 0:
fmt.Println("1")
case a == 5:
fmt.Println("2")
case a >= 3:
fmt.Println("3")
}
/*
输出：3
*/
}

go中的switch语句，执行完case后会跳出switch，使用fallthrough语句可以在执行完一个case后跳转到下一个case，fallthrough 语句应该是 case 子句的最后一个语句，否则会报错fallthrough statement out of place

package main
import "fmt"
func main() {
switch a := 5; {
case a >= 0:
fmt.Println("1")
fallthrough//符合该case，执行表达式，完成后跳到下一个case
case a >= 5:
fmt.Println("2")
fallthrough
case a >= 3:
fmt.Println("3")
}
/*
输出：
1
2
3
*/
}

当switch语句中，case所有值都不符合时，可以使用default指定一个默认的表达式，default可以放在switch语句的任何地方

package main
import "fmt"
func main() {
switch a := 5;a {
case 1:
fmt.Println("1")
case 2:
fmt.Println("2")
case 3:
fmt.Println("3")
default://默认情况
fmt.Println("default")
}
/*
输出：
default
*/
}

循环语句

for循环

for循环语句语法如下，初始化语句只执行一次，初始化后，将检查循环条件，如果条件的计算结果为 true ，则 {} 内的循环体将执行，接着执行循环结束执行语句；循环结束执行语句将在每次成功循环迭代后执行，之后，循环条件将被再次检查；如果仍 true, 则循环将继续执行，否则 for 循环将终止。for 循环中声明的变量只能在循环体内访问，初始语句可以被忽略，但是初始语句之后的分号必须要写

for 初始化表达式或赋值语句;循环条件;循环结束执行语句 {
循环体
}

例子：

package main
import (
"fmt"
)
func main() {
//利用for循环输出1~10
for i:= 1;i <= 10;i++ {
fmt.Print(i)
}
}

for循环可以被 break、return、goto等语句强制退出，强制退出后，循环结束执行语句不会执行；continue可以退出当前循环。

• break:
  用于在for循环完成正常执行前退出整体for循环，程序从for循环下一行语句开始继续执行

package main
import (
"fmt"
)
func main() {
//利用for循环输出1~10
for i:= 1;i <= 10;i++ {
//当i=5时跳出整体循环，所以不会输出i
if i == 5 {
break//跳出循环
}
fmt.Print(i)
}
//跳出循环后继续执行
fmt.Println("跳出循环了")
/*
运行输出结果：
1234跳出循环了
*/
}

• return:返回语句，在for循环中使用return，会跳出整个for循环，还会直接跳出for循环所在函数

package main
import (
"fmt"
)
func main() {
//利用for循环输出1~10
for i:= 1;i <= 10;i++ {
//当i=5时跳出循环，所以不会输出5
if i == 5 {
return//跳出循环
}
fmt.Print(i," ")
}
//使用return会直接跳出函数，不会执行以下语句
fmt.Println("-------------")
/*
运行输出结果：
1 2 3 4
*/
}

• goto:goto语句可以通过标签进行代码间的无条件转换，一般用于跳出多重循环

package main
import (
"fmt"
)
func main() {
//第一层循环
for i := 1;i <= 10;i++ {
//第二层循环
fmt.Printf("一：%d\n",i)
for j := 1;j <= 10;j++ {
fmt.Printf("二：%d\n",j)
if j == 2 {
//退出多重循环，跳到标签所在代码行
goto gotoHere
}
}
}
//标签
gotoHere:
fmt.Println("跳出多重循环到此处")
/*
运行输出结果：
一：1
二：1
二：2
跳出多重循环到此处
*/
}

• continue:用于跳出for循环中当前的一次循环，continue之后的循环语句在当前循环中都不会执行，但之后的循环仍然会执行

package main
import (
"fmt"
)
func main() {
//利用for循环输出1~10
for i:= 1;i <= 10;i++ {
//当i=5时跳出此次循环，所以不会输出5，但之后的仍旧会输出
if i == 5 {
continue//跳出循环
}
fmt.Print(i," ")
}
/*
运行输出结果：
1 2 3 4 6 7 8 9 10
*/
}