顺序语句
…
条件语句
if
- if与表达式中间应当有一个空格
- Go中{}一定要有，一行代码的情况也不能简写
package main
import "fmt"
func main() {
var score int
n, err := fmt.Scanln(&score)
fmt.Println(n, err)
var level byte
if addition := 5; score+addition < 60 {
level = 'D'
} else if score+addition <= 80 {
level = 'C'
} else if score+addition <= 90 {
level = 'B'
} else {
level = 'A'
}
}
switch
- switch后可以跟什么值？常量、变量、函数
- switch后不跟值时，默认为bool类型，case中应当是bool类型，这时switch等价于if
- case后的数据类型必须与switch后的数据类型一致
- case后可以跟多个值，使用逗号间隔
- case后面的常量值不能重复
- Go中case后无需添加break，匹配到case执行完后会退出，没有匹配到执行default
- fallthrough，case穿透，在case后添加fallthrough，会执行下一个case
- default非必须，且Go中default位置任意
package main
import "fmt"
func main() {
nums := 20
switch {
default:
fmt.Println("default")
case nums <= 5:
fmt.Println("<= 5")
case nums <= 10:
fmt.Println("<= 10")
case nums <= 15:
fmt.Println("<= 15")
case nums <= 20:
fmt.Println("<= 20")
fallthrough
case nums <= 25:
fmt.Println("<= 25")
break
case nums <= 30:
fmt.Println("<= 30")
}
}
// <= 20
// <= 25
//同样支持一行赋值
package main
import "fmt"
func main() {
switch b := 7; {
case b < 7:
fmt.Println("A")
case b >= 7:
fmt.Println("B")
}
}
type switch
package main
import (
"fmt"
)
func main() {
//switch类型判断
var x any = 10.0 //type any = interface{}
fmt.Printf("%T", x)
switch t := x.(type) {
case nil:
fmt.Printf("the type of t %v is nil", t)
case int:
fmt.Printf("the type of t %v is int", t)
case bool:
fmt.Printf("the type of t %v is bool", t)
case func(int):
fmt.Printf("the type of t %v is func(int)", t)
default:
fmt.Printf("the type of t %v is unknown", t)
}
}
循环语句
for
循环语句
for语句
package main
import "fmt"
func main() {
for i := 0; i < 10; i++ { // 这里只能用 := 方式
fmt.Println("Hello World")
}
j := 0
for j < 10 {
fmt.Println("Hello World")
j++
}
for { //for ;;
fmt.Println("Hello World")
}
}
注意：Go中无while、do while语句，但是for格式灵活，很容易改写为while、do while形式，而从编程语言理论角度而言，for本身便可替代while、do while，实际应用中也是for为主
for range
可以遍历数组、切片、字符串、map、通道
package main
import "fmt"
func main() {
s := "hello 世界"
for i := 0; i < len(s); i++ {
fmt.Printf("(%c)", s[i])
} //乱码
fmt.Println()
for index, value := range s {
fmt.Printf("%d=%c ", index, value)
} //0=h 1=e 2=l 3=l 4=o 5= 6=世 9=界
}
break
跳出某层循环，默认跳出最近外层循环，支持使用标签指定某一层循环
package main
import "fmt"
func main() {
aLabel:
for i := 0; i < 10; i++ {
for j := 0; j < 10; j++ {
if i == 1 {
fmt.Println("i=1")
break
} else if i == 5 {
break aLabel
} else {
}
fmt.Println(i, j)
}
}
}
continue
跳过某次循环，默认跳过本次循环，支持使用标签指定某一层循环的这一次
goto
无条件转移，与if配合使用可以实现条件转移，一般地，Go中也不建议使用goto
汇编语言中转移语句才是真正发挥作用的地方，高级语言一般不用
package main
import (
"fmt"
)
func main() {
label0:
fmt.Println("label0")
var i int
fmt.Scanln(&i)
if i == 1 {
goto label1
} else if i == 2 {
goto label2
} else {
goto label0
}
label1:
fmt.Println("label1")
label2:
fmt.Println("label2")
}
return
return // 什么也不返回，不是nil
return 1