Go的流程控制语句
for
Go 只有一种循环结构:for
循环。
和 C、Java、JavaScript 之类的语言不同,Go 的 for 语句后面的三个构成部分外没有小括号()
package main
import "fmt"
//寻常for循环
func main() {
sum := 0
for i := 0; i <= 10; i++ {
sum += i
}
fmt.Println(sum)
}
while
package main
import "fmt"
//while
func main() {
sum := 1
//法一
for ; sum <= 10; {
sum += sum
}
fmt.Println(sum)
// 法二 更像 While 语句形式
for sum <= 10{
sum += sum
}
fmt.Println(sum)
}
For-each range
这种格式的循环可以对字符串、数组、切片等进行迭代输出元素。
package main
import "fmt"
func main() {
strings := []string{"google","runoob"}
for i,s := range strings{
fmt.Println(i,s)
}
numbers := [6]int{1, 2, 3, 5}
for i,x:= range numbers{
fmt.Printf("第%d位x的值 = %d\n",i,x)
}
}
if
Go 的 if
语句与 for
循环类似,表达式外无需小括号 ( )
,而大括号 { }
则是必须的。
package main
import "fmt"
func main() {
/* 定义局部变量 */
var a int = 10
/* 使用 if 语句判断布尔表达式 */
if a < 20 {
/* 如果条件为 true 则执行以下语句 */
fmt.Printf("a 小于 20\n" )
}
fmt.Printf("a 的值为 : %d\n", a)
}
switch
switch 默认情况下 case 最后自带 break 语句,匹配成功后就不会执行其他 case.
如果我们需要执行后面的 case,可以使用 fallthrough 。
package main
import "fmt"
func main() {
test5()
}
//switch
func test3() {
/* 定义局部变量 */
var grade string = "B"
var marks int = 90
switch marks {
case 90: grade = "A"
case 80: grade = "B"
case 50,60,70 : grade = "C"
default: grade = "D"
}
switch {
case grade == "A" :
fmt.Printf("优秀!\n" )
case grade == "B", grade == "C" :
fmt.Printf("良好\n" )
case grade == "D" :
fmt.Printf("及格\n" )
default:
fmt.Printf("不及格\n" )
}
fmt.Printf("你的等级是 %s\n", grade )
}
//Type Switch
func test4() {
//interface:一个空类型
var x interface{}
switch i := x.(type) {
case nil:
fmt.Printf(" x 的类型 :%T",i)
case int:
fmt.Printf("x 是 int 型")
case float64:
fmt.Printf("x 是 float64 型")
case func(int) float64:
fmt.Printf("x 是 func(int) 型")
case bool, string:
fmt.Printf("x 是 bool 或 string 型" )
default:
fmt.Printf("未知型")
}
}
//fallthrough
//如果 case 带有 fallthrough,程序会继续执行下一条 case,且它不会去判断下一个 case 的表达式是否为 true。
//但是下面的6并没有输出
//说明default不受fallthrough管
func test5() {
switch {
case false:
fmt.Println("1、case 条件语句为 false")
fallthrough
case true:
fmt.Println("2、case 条件语句为 true")
fallthrough
case false:
fmt.Println("3、case 条件语句为 false")
fallthrough
case true:
fmt.Println("4、case 条件语句为 true")
case false:
fmt.Println("5、case 条件语句为 false")
fallthrough
default:
fmt.Println("6、默认 case")
}
}
select
select 是 Go 中的一个控制结构,类似于用于通信的 switch 语句。每个 case 必须是一个通信操作,要么是发送要么是接收。
select 随机执行一个可运行的 case。如果没有 case 可运行,它将阻塞,直到有 case 可运行。一个默认的子句应该总是可运行。
chan:
chan又称之为通道,形式类似于管道,内容从一头被送进去,从另一头被读取出来。
定义通道时,需要指定数据类型,就是只允许这个指定数据类型的变量通过这个通道
golang中在初始化通道类型变量时,可以将通道分为两种情况,一种是带缓冲的通道,另一种是不带缓冲的通道。
package main
import "fmt"
func main() {
var c1, c2, c3 chan int
var i1, i2 int
select {
case i1 = <-c1:
fmt.Printf("received ", i1, " from c1\n")//接收
case c2 <- i2:
fmt.Printf("sent ", i2, " to c2\n")//发送
case i3, ok := (<-c3): // same as: i3, ok := <-c3
if ok {
fmt.Printf("received ", i3, " from c3\n")//接收
} else {
fmt.Printf("c3 is closed\n")
}
default:
fmt.Printf("no communication\n")
}
}
defer
defer 语句会将函数推迟到外层函数返回之后执行。
推迟调用的函数其参数会立即求值,但直到外层函数返回前该函数都不会被调用。
package main
import "fmt"
func main() {
defer fmt.Println("world")
fmt.Println("hello")
}
defer 栈
推迟的函数调用会被压入一个栈中。当外层函数返回时,被推迟的函数会按照后进先出的顺序调用。
package main
import "fmt"
func main() {
fmt.Println("counting")
for i := 0; i < 10; i++ {
defer fmt.Println(i)
}
fmt.Println("done")
}
break
可使用标记
package main
import "fmt"
func main() {
// 不使用标记
fmt.Println("---- break ----")
for i := 1; i <= 3; i++ {
fmt.Printf("i: %d\n", i)
for i2 := 11; i2 <= 13; i2++ {
fmt.Printf("i2: %d\n", i2)
break //只跳出了一个循环
}
}
// 使用标记
fmt.Println("---- break label ----")
re: //标记!
for i := 1; i <= 3; i++ {
fmt.Printf("i: %d\n", i)
for i2 := 11; i2 <= 13; i2++ {
fmt.Printf("i2: %d\n", i2)
break re //回到标记处
}
}
}
三目运算符
go没有三目运算符
=V=