从零开始学GO ---- if-else语句、switch语句、for语句、标签和跳转

怼烎@ 2022-12-20 00:28 33阅读 0赞

### 从零开始学GO ---- if-else语句、switch语句、for语句、标签和跳转 ###

程序执行本质上来说就是两种模式：顺序和跳转

*  顺序就是按照程序指令在存储器上的存放顺序逐条执行
 *  跳转就是遇到跳转指令就跳转到某处继续线性执行

顺序在Go里面体现在从main函数开始逐条向下执行，跳转体现在包括goto语句、函数调用以及分支循环等。

#### if-else语句 ####

if-else语句的通常写法：

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

*  if后面的条件判断子句不需要小括号括起来
 *  \{必须放在行尾，和if或者if else放在一行
 *  if后可以带一个简单的初始化语句，并以分号分隔，这个简单语句声明的变量作用域是整个if语句块，包括后面的if else和else分支
    
        func main() {
              
        	if score := 65; score >= 90 {
              
        		fmt.Println("A")
        	} else if score > 75 {
              
        		fmt.Println("B")
        	} else {
              
        		fmt.Println("C")
        	}
        }
 *  if分支语句遇到return则直接返回，遇到break则跳过break下方的if语句

#### switch语句 ####

switch语句会根据传入的参数检测并执行符合条件的分支

func main() {
        
    	switch i := "y"; i {
         //switch后面可以带上一个初始化语句
    	case "y", "Y": //可以匹配多个值，用逗号分开即可
    		fmt.Println("Yes")
    		fallthrough //fallthrough会跳过接下来的case条件判断句，直接执行下一个case语句
    	case "n", "N":
    		fmt.Println("No")
    	}
    	//输出  YES  NO
    }

*  switch条件表达式可以支持任何可以进行比较运算的类型变量
 *  通过fallthrough可以来强制执行下一个case语句(不需要判断是否满足)
 *  switch支持default语句，当所有的case分支都不符合时，执行default语句，default可以放在任意位置

#### for语句 ####

Go语言只支持一种循环语句，即for语句。

类似于C++的for循环模式：`for init;condition;post{}`

类似于C++中的while循环模式：`for condition{}`

类似于C++中的while(1)循环模式： `for{}`

func main() {
    	for i := 1; i < 10; i++ {
    		fmt.Printf("%d ", i)
    	}
    	//1 2 3 4 5 6 7 8 9
    }

Go语言中可以使用`for range`遍历数组、切片、字符串、map 及通道（channel）

//访问map
    for key,value:=range map{
        }
    for key:=range map{
        }
    //访问数组
    for index,value:=range array{
        }
    for _,value:=range array{
        }
    //访问切片
    for index,value:=range slice{
        }
    for _,value:=range slice{
        }

#### 标签和跳转 ####

Go语言使用标签来标识一个语句的位置，用于goto、break、continue语句的跳转 `Lable:Statement`

goto语句：用于函数的内部跳转，需要配合标签使用 `goto Lable`

*  goto语句只能在函数内进行跳转
 *  goto语句不能跳过内部变量声明语句
    
        goto L
        	v:=3         //这是不允许的，不允许跳过v:=3
        L:
 *  goto语句只能跳到同级或者上层作用域，不可以跳到内部作用域

func gotoDemo() {
        
    	for i := 0; i < 10; i++ {
        
    		for j := 0; j < 10; j++ {
        
    			if j == 2 {
        
    				// 设置退出标签
    				goto breakTag
    			}
    			fmt.Printf("%v-%v\n", i, j)
    		}
    	}
    	return
    	// 标签
    breakTag:
    	fmt.Println("结束for循环")
    }

`break`语句：用于跳出for switch select语句的执行

*  单独使用break，可以跳出break当前所在的for switch select语句
 *  配合标签一起使用，用于跳出标签所标识的for switch select语句

func main() {
        
    L1:
    	for i := 0; ; i++ {
        
    		for j := 0; ; j++ {
        
    			fmt.Printf("i:%d j:%d\n", i, j)
    			if i >= 1 {
        
    				break L1 //跳出L1标签所在的for循环
    			}
    			if j > 10 {
        
    				break //跳出离break最近的内层循环
    			}
    		}
    	}
    }
    //运行结果：
    i:0 j:0
    i:0 j:1
    i:0 j:2
    i:0 j:3
    i:0 j:4
    i:0 j:5
    i:0 j:6
    i:0 j:7
    i:0 j:8
    i:0 j:9
    i:0 j:10
    i:0 j:11   //此时j>10 跳出了内层循环
    i:1 j:0    //此时i>=1,跳出了L1标记的循环，即外循环

`continue`语句用于跳出for循环的本次迭代，跳到for循环的下一次迭代的post语句处执行

*  单独使用continue，用于跳出continue当前所在的for循环的本次迭代
 *  和标签一起使用，用于跳出标签所标识的for语句的本次迭代

func main() {
        
    L1:
    	for i := 0; ; i++ {
        
    		for j := 0; ; j++ {
        
    			if i == 1 {
        
    				continue L1 //跳到L1标签所在的for循环的下一次，即i=2的下一轮循环
    			}
    			if j==10 {
         
    				continue   //跳过j==10这一次的内圈循环，即开始j=11的下一轮循环
    			}
    		}
    	}
    }