愉快地周末过去了，今天给大家打来的是–“流程控制语句”
if-else
用于判断某个条件，条件成立，执行if 后边大括号里的内容，不成立则执行后续代码
if a > 10 {
return 1
} else {
return 2
}
当然了， else if 在这里同样生效
if a > 10 {
return 1
} else if a == 10 {
return 2
} else if {
return 3
}
完整示例代码：
package main
import (
"fmt"
)
func GetA() (a int) {
a = 1
if a > 10 {
return 1
} else {
return 2
}
}
func main() {
var b = GetA()
fmt.Println("返回: ", b)
}
这里说一下我的踩坑经验，因为我也是初学者，所以并不了解Go语言的规则，书中也没有写，此次记录如下：
-
任何内容必须写在函数体内
-
主main函数不可返回return值
3.不可缺少主main函数
for 循环
Go语言仅支持for循环，没有while和do-while循环
product := 1
for i := 1; i < 5 ; i ++ {
product *= i
}
for if 嵌套
i := 0
for{
i ++
if i > 50 {
break
}
}
需要注意的是
-
左大括号“{”必须和 for同一行
-
Go语言的for循环允许在循环条件内定义初始化变量，不支持多个值逗号间隔，必须平行赋值多个变量
-
Go语言支持continue 和 break来控制循环，更支持break中断哪一个循环
循环作用域
这里的作用域，大家可以理解为类似于局部变量和全局变量的区别，当初始化变量写在for循环中的时候，他的作用于尽在循环内生效，若是写在循环外部，则会全局生效，他的作用域大于循环内的作用于，示例代码如下
1.内部作用变量a
for a :=0 ; a < 5 ; a++{
fmt.Println(a)
}
2.外部作用变量a
a := 0
for ; a < 5 ; a++{
fmt.Println(a)
}
大家可以看见，第二种方式初始化为空，但是依然需要使用分号来进行隔断，这是必须有的格式
省略表达式
大家可以看见，中间部位a<5 为判断条件，当条件符合时，会一直执行，当条件不符合时，则停止循环，若是将之去掉省略，循环会默认死循环，即无限循环，可以配合if进行填写
a := 0
JumpLoop
for ; ; a++ {
if a > 5 {
break JumpLoop
}
}
当然了，甚至连 a ++ 都可以省略，他会默认每次都调用此条件，使代码进一步简洁，并且美观，无需再使用分号进行占位
a := 0
for {
if a > 5 {
break
}
a++
}
再次简写
a := 0
for a < 5 {
a++
}
当然了，甚至连 a ++ 都可以省略，他会默认每次都调用此条件，使代码进一步简洁，并且美观，无需再使用分号进行占位
a := 0
for {
if a > 5 {
break
}
a++
}
再次简写
a := 0
for a < 5 {
a++
}
}
for-rang 循环
for-rang循环结构是go语言特有的一种迭代结构，可以遍历数组、切片、字符串、map及通道
一般形式如下
for key, value := range 复合变量值{
//逻辑语句
}
for position, char := range str {
//逻辑语句
}
每个rune字符和索引在for-range循环中的值是一一对应的，他能自动根据UTF-8规则识别Unicode编码 的字符
for-range遍历的返回值规律如下
1.数组、切片、字符串返回索引和值
2.Map返回键和值
通道(channel)只返回通道内的值
遍历切片
案例如下：key和value分别代表切片的下标及下标对应的值
package main
import (
"fmt"
)
func main() {
for key, value := range []int{
0, 1, -1, -2} {
fmt.Printf("key:%d value:%d\n", key, value)
}
}
需要注意的是，这里使用的是pringf，而非println
遍历字符串案例
package main
import (
"fmt"
)
func main() {
var str = "hi"
for key, value := range str {
fmt.Printf("key:%d value:0x%x\n", key, value)
}
}
此时出来的其实是十六进制的值，如果使用%d进行占位的话，默认是ascii值
遍历map
对于map类型，key和value分别代表map的索引建和值，只不过在输出的时候，输出的键是无序的，若是想要有序输出，需要对结果进行自排序
package main
import (
"fmt"
)
func main() {
m := map[string]int{
"go": 100,
"web": 100,
}
for key, value := range m {
fmt.Println(key, value)
}
}
遍历通道
通道可以通过for range进行遍历，在遍历通道的时候只输出一个值，即通道内类型对应的数据
// var.go
package main
import (
"fmt"
)
func main() {
c := make(chan int) //创建了一个整形类型的通道
go func() {
//启动了一个goroutine
c <- 7 //将数据推进通道
c <- 8
c <- 9
close(c)
}()
for v := range c {
fmt.Println(v)
}
}
匿名变量
下划线匿名变量可以将之理解为一种占位符，匿名变量不参与空间分配，也不会占用一个变量的名字
同样的，输出的内容也可以对key/value单独输出
package main
import (
"fmt"
)
func main() {
m := map[string]int{
"go": 100,
"web": 100,
}
for _, value := range m {
fmt.Println(value)
}
}
Switch-case语句
表达式的值不必为常量，甚至不用是整数。Case从上到下的顺序进行求值，直到找到匹配的项。Case与case之间是独立的代码块，不需要通过break来结束当前的代码块。Go语言规定，每个switch 只能有一个default分支
package main
import (
"fmt"
)
func main() {
var a = "love"
switch a {
case "love":
fmt.Println("love")
case "programing":
fmt.Println("programing")
default:
fmt.Println("none")
}
}
Go语言的一个分支多个支的写法：
package main
import (
"fmt"
)
func main() {
var language = "golang"
switch language {
case "golang", "java":
fmt.Println("popular languages")
}
}
分支表达式：
package main
import (
"fmt"
)
func main() {
var r int = 6
switch {
case r > 1 && r < 10:
fmt.Println(r)
}
}
Goto语句
Goto语句用来跳转至指定标签，进行代码间的无条件跳转。
package main
import (
"fmt"
)
func main() {
for x := 0; x < 5; x++ {
//外循环
for y := 0; y < 5; y++ {
//内循环
if y == 2 {
//条件语句
goto breakTag //跳转到标签
}
}
}
return
breakTag:
fmt.Println("done")
}
此处 breakTag为自定义标签，return若是不手动返回，条件不成立也会执行breakTag代码
此处用法多用于，多次调用
break语句
Go标签中的break语句同样可以结束for、switch、和select代码块，此处在for循环中有介绍
// var.go
package main
import (
"fmt"
)
func main() {
OuterLoop: //外层循环的标签
for i := 0; i < 2; i++ {
//外循环
for j := 0; j < 5; j++ {
//内循环
switch j {
//用switch进行数值分支j进行判断
case 1: //条件满足 j=1时，结束标签
fmt.Println(i, j)
break OuterLoop //退出标签到对应的循环之外
case 2:
fmt.Println(i, j)
break OuterLoop
}
}
}
}
Continue语句
Continue语句用来结束当前循环，并开始下一次循环的迭代过程，它仅限在循环内部使用。若是在continue后添加标签，表示结束标签对应的语句的当前循环，并开启下一次的外循环。
package main
import (
"fmt"
)
func main() {
OuterLoop:
for i := 0; i < 2; i++ {
for j := 0; j < 5; j++ {
switch j {
case 3:
fmt.Println(i, j)
continue OuterLoop
}
}
}
}
今天的分享就到这了，一天学习十分钟，卷死别人