【Go语言】流程控制

开启掘金成长之旅！这是我参与「掘金日新计划 · 12 月更文挑战」的第8天，点击查看活动详情

if语句分析

1. 结构：

if 表达式为true {

执行语句

}

结构分解：

解析：在Go语言中，代码块必须由花括号包裹。另外，这里的条件表达式是指其结果类型是bool的表达式。if条件语句需要开发者通过指定一个或多个条件，并通过测试条件是否为 true 来决定是否执行指定语句，并在条件为 false 的情况在执行另外的语句。该表达式中使用true达成执行条件输出true。

2. 举例： 请用if语句判断bool类型进行输出。

 if true {                                                         //if语句判断
    fmt.Println("true")                                            //语句&表达式输出
 }      

终端输出：

结构解析：

 if true {                                                         //if语句判断
  }  

if* *语句判断：**if条件语句需要开发者通过指定一个或多个条件，并通过测试条件是否为 true 来决定是否执行指定语句，并在条件为 false 的情况在执行另外的语句。该语句使用true达成执行条件输出true。

 fmt.Println("true")                                            //语句&表达式输出

语句&表达式输出：fmt.Println(...) 可以将字符串输出到控制台，并在最后自动增加换行字符 \n。函数内语句依照main函数内依次执行。

if…else 语句分析

1. 结构：

if 条件1

{

当条件为 true 时执行的代码

}

else if 条件2

{

当条件不为 true 时执行的代码

}

else {

}

结构分解：

解析： 在Go语言中，代码块必须由花括号包裹。另外，这里的条件表达式是指其结果类型是bool的表达式。if条件语句需要开发者通过指定一个或多个条件，并通过测试条件是否为 true 来决定是否执行指定语句，并在条件为 false 的情况在执行另外的语句。此语句中先执行判断语句如果判断结果为true,则执行第一个条件下的语句表达式，若为false则继续往下判断执行第二个语句判断，如果判断结果为true,则执行第二个语句表达式，如此往复知道输出结束。

2. 举例： 请用if…else 语句判断条件进行输出。

 total := 10                                                      //变量的声明
 if total < 10 {                                                    //条件判断
    fmt.Println("total<10")                                        //语句&表达式输出
 } else if total == 10 {
    fmt.Println("total=10")
 } else {
    fmt.Println("total>10")
 }      

终端输出：

结构解析：

 total := 10                                                      //变量的声明    

变量的声明赋值： Go语言是静态类型语言，因此变量（variable）是有明确类型的。编译器会检查函数调用中，变量类型的正确性。在数学概念中，变量表示没有固定值且可改变的数。但从计算机系统实现角度来看，变量是一段或多段用来存储数据的内存。

 if total < 10 {                                                    //条件判断
 } else if total == 10 {
 } else {
 } 

if…else 语句判断： if条件语句需要开发者通过指定一个或多个条件，并通过测试条件是否为 true 来决定是否执行指定语句，并在条件为 false 的情况在执行另外的语句。此语句中先执行判断语句如果判断结果为true,则执行第一个条件下的语句表达式，若为false则继续往下判断执行第二个语句判断，如果判断结果为true,则执行第二个语句表达式，如此往复知道输出结束。

 fmt.Println("total<10")                                        //语句&表达式输出
 fmt.Println("total=10")
 fmt.Println("total>10")

语句&表达式输出：fmt.Println(...) 可以将字符串输出到控制台，并在最后自动增加换行字符 \n。函数内语句依照main函数内依次执行。

if 嵌套语句分析

1. 结构：

if 布尔表达式 1 {

if 布尔表达式 2 {

}

}

结构分解：

解析： 在Go语言中，代码块必须由花括号包裹。if条件语句需要开发者通过指定一个或多个条件，并通过测试条件是否为 true 来决定是否执行指定语句，并在条件为 false 的情况在执行另外的语句。在if嵌套语句中执行时，语句先判断第一个条件表达式，当布尔判断类型为true时，进入第二层嵌套语句判断，再次判断布尔语句的条件，依旧为true则输出语句表达式。

2. 举例： 请用if 嵌套语句判断条件进行输出。

 name := "知链区块链人才培养摇篮"                              //变量的声明
 age := 20180516                                              
 if name == "知链区块链人才培养摇篮" {                          //if嵌套语句
    if age == 20180516 {
       fmt.Println("恭喜你学会了if 嵌套语句")                    //语句&表达式输出
    }
 } 

终端输出：

结构解析：

name := "知链区块链人才培养摇篮"                              //变量的声明
age := 20180516    

变量的声明赋值： Go语言是静态类型语言，因此变量（variable）是有明确类型的。编译器会检查函数调用中，变量类型的正确性。在数学概念中，变量表示没有固定值且可改变的数。但从计算机系统实现角度来看，变量是一段或多段用来存储数据的内存。

if name == "知链区块链人才培养摇篮" {                          //if嵌套语句
   if age == 20180516 {
   }
}     

if* *嵌套语句判断：**在if嵌套语句中执行时，语句先判断第一个条件表达式，当布尔判断类型为true时，进入第二层嵌套语句判断，再次判断布尔语句的条件，依旧为true则输出语句表达式。

fmt.Println("恭喜你学会了if 嵌套语句")                    //语句&表达式输出

语句&表达式输出：fmt.Println(...) 可以将字符串输出到控制台，并在最后自动增加换行字符 \n。函数内语句依照main函数内依次执行。

switch无表达式的语句分析

1. 结构：

switch var1 {

case val1:

...

case val2:

...

default:

...

}

结构分解：

解析：在Go语言中，代码块必须由花括号包裹。另外，这里的条件表达式是指其结果类型是bool的表达式。变量 var1 可以是任何类型，而 val1 和 val2 则可以是同类型的任意值。类型不被局限于常量或整数，但必须是相同的类型；或者最终结果为相同类型的表达式。

2. 举例： 请用switch无表达式语句进行判断输出。

var i = 0                                                     //变量的声明赋值
switch i {                                                 //switch无表达式语句输出
case 0:
   fmt.Println(0)
case 1:
   fmt.Println(1)
case 2:
   fmt.Println(2)
default:
   fmt.Println("default")
}

终端输出：

结构解析：

var i = 0                                                     //变量的声明赋值

变量的声明赋值： Go语言是静态类型语言，因此变量（variable）是有明确类型的。编译器会检查函数调用中，变量类型的正确性。在数学概念中，变量表示没有固定值且可改变的数。但从计算机系统实现角度来看，变量是一段或多段用来存储数据的内存。

switch i {                                                 //switch无表达式语句输出
case 0:
case 1:
case 2:
default:
   }

switch* *无表达式语句：**switch语句从字面上讲，可以称为开关语句，当然理解上不要以为就只有开和关，可以想象它是一个多路开关。它是一种多分支结构。它的使用基于不同条件执行不同动作，每一个 case 分支都是唯一的，所有 case 分支的参数必须是相同的类型，语句执行的过程从上至下，直到找到匹配项，匹配项后面也不需要再加 break 默认自动终止。

fmt.Println(0)                                        //语句&表达式输出
fmt.Println(1)
fmt.Println(2) 
fmt.Println("default")

语句&表达式输出：fmt.Println(...) 可以将字符串输出到控制台，并在最后自动增加换行字符 \n。函数内语句依照main函数内依次执行。

switch有表达式的语句分析

1.结构：

switch(表达式)

{

case 常量表达式1:语句1

case 常量表达式2:语句2

case 常量表达式n-1:语句n-1

default：语句n

}

结构分解：

解析：在Go语言中，与if语句一样，switch语句还可以包含初始化语句，且其出现位置和写法也如出一辙。在表达式的过程中首先计算出表达式的值。其次，和case依次比较，一旦有对应的值，就会执行相应的语句,最后，如果所有的case都和表达式的值不匹配，就会执行default语句体部分，然后程序结束掉。

2. 举例： 请用switch有表达式语句进行判断输出。

switch name := names[0]; name {                     //switch有表达式语句输出
case "知链":
   fmt.Println("知链")
case "区块链":
   fmt.Println("区块链")
case "人才培养":
   fmt.Println("人才培养")
case "摇篮":
   fmt.Println("摇篮")
default:
   fmt.Println("知链区块链人才培养摇篮")
}

终端输出：

结构解析：

switch name := names[0]; name {                      //switch有表达式语句输出
case "知链":
case "区块链":
case "人才培养":
case "摇篮":
default:
}

switch* *有表达式语句：**switch语句从字面上讲，可以称为开关语句，当然理解上不要以为就只有开和关，可以想象它是一个多路开关。它是一种多分支结构。它的使用基于不同条件执行不同动作，每一个 case 分支都是唯一的，所有 case 分支的参数必须是相同的类型，语句执行的过程从上至下，直到找到匹配项，匹配项后面也不需要再加 break 默认自动终止。

fmt.Println("知链")                                       //语句&表达式输出
fmt.Println("区块链")
fmt.Println("人才培养")
fmt.Println("摇篮")
fmt.Println("知链区块链人才培养摇篮")

语句&表达式输出：fmt.Println(...) 可以将字符串输出到控制台，并在最后自动增加换行字符 \n。函数内语句依照main函数内依次执行。

switch多表达式的语句分析

1. 结构：

swtich(表达式) {

case 常量1，常量2，常量3 : 语句1

case 常量4 : 语句3

case 常量5 : 语句4

default: 语句n

}

结构分解：

解析：在Go语言中，与if语句一样，switch语句还可以包含初始化语句，且其出现位置和写法也如出一辙。在表达式的过程中首先计算出表达式的值。它的使用基于不同条件执行不同动作，与一般的单一条件表达式不同的是，每一个 case 分支的表达式不是唯一的可以有多个，但依旧所有 case 分支的参数必须是相同的类型，语句执行的过程从上至下，直到找到匹配项，匹配项后面也不需要再加 break 默认自动终止。

2. 举例： 请用switch多表达式语句进行判断输出。

var t = 1                                                     //变量的声明赋值
switch t {                                                  //switch有表达式语句输出
case 0, 1:
   fmt.Println("知链科技")
case 2:
   fmt.Println("区块链")
default:
   fmt.Println("default")
}

终端输出：

结构解析：

var t = 1                                                     //变量的声明赋值

变量声明赋值：在Go语言中给变量的声明赋值可以分为三个阶段，先创建变量，在内存中开辟空间后再初始化变量，将变量初始化为underfined,最后再进行真正赋值。

switch t {                                                  //switch有表达式语句
case 0, 1:
case 2:
default:
   }

switch* 多表达式语句：switch语句从字面上讲，可以称为开关语句，当然理解上不要以为就只有开和关，可以想象它是一个多路开关。它是一种多分支结构。 它的使用基于不同条件执行不同动作，与一般的单一条件表达式不同的是，每一个 case 分支的表达式不是唯一的可以有多个，但依旧所有 case 分支的参数必须是相同的类型，语句执行的过程从上至下，直到找到匹配项，匹配项后面也不需要再加 break 默认自动终止。*

fmt.Println("知链科技")                                        //语句&表达式输出
fmt.Println("区块链")
fmt.Println("default")

语句&表达式输出：fmt.Println(...) 可以将字符串输出到控制台，并在最后自动增加换行字符 \n。函数内语句依照main函数内依次执行。

switch多表达式的条件语句分析

1. 结构：

swich(表达式)

{

case 表达式1&&表达式2 ：语句1；

case 表达式2&&表达式3：语句2；

case 表达式3&&表达式4：语句3；

...

default 表达式.. ：语句n+1;

}

结构分解：

解析： 在Go语言中，与if语句一样，switch语句还可以包含初始化语句，且其出现位置和写法也如出一辙。在表达式的过程中首先计算出表达式的值。它的使用基于不同条件执行不同动作，与一般的单一条件表达式不同的是，条件表达式中的匹配条件不是单一的，而是多条件复合条件匹配，他们在书写时不需要使用括号{}括起来，而在多条件复合情况下必须满足该case后的所有条件后语句才能执行。其次与其他switch语句情况不同的是各case和 default子句的先后顺序是可以变动的，且不会影响程序结果。

2. 举例： 请用switch条件表达式语句进行判断输出。

var a4 = 10                                                   //变量的声明赋值
switch {                                                 //switch条件表达式语句输出
case a4 >= 0 && a4 < 10:
   fmt.Println("a4 > 0 and a4 < 10")
case a4 >= 10 && a4 < 20:
   fmt.Println("a4 > 10 and a4 < 20")
default:
   fmt.Println("default")
}

终端输出：

结构解析：

var a4 = 10                                                   //变量的声明赋值

变量声明赋值：在Go语言中给变量的声明赋值可以分为三个阶段，先创建变量，在内存中开辟空间后再初始化变量，将变量初始化为underfined,最后再进行真正赋值。

switch {                                                 //switch条件表达式语句输出
case a4 >= 0 && a4 < 10:
case a4 >= 10 && a4 < 20:
default:
}

switch* *条件表达式语句：**条件表达式的使用基于不同条件执行不同动作，与一般的单一条件表达式不同的是，条件表达式中的匹配条件不是单一的，而是多条件复合条件匹配，他们在书写时不需要使用括号{}括起来，而在多条件复合情况下必须满足该case后的所有条件后语句才能执行。其次与其他switch语句情况不同的是各case和 default子句的先后顺序是可以变动的，且不会影响程序结果。

fmt.Println("a4 > 0 and a4 < 10")                         //语句&表达式输出
fmt.Println("a4 > 10 and a4 < 20")
fmt.Println("default")

语句&表达式输出：fmt.Println(...) 可以将字符串输出到控制台，并在最后自动增加换行字符 \n。函数内语句依照main函数内依次执行。