Go语言专题（三）：条件语句和循环语句

Go语言条件语句

条件语句需要开发者通过指定一个或多个条件，并通过测试条件是否为 true 来决定是否执行指定语句，并在条件为 false 的情况在执行另外的语句。

下图展示了程序语言中条件语句的结构：

Go语言提供了以下几种条件判断语句：

if 语句

if 语句由布尔表达式后紧跟一个或多个语句组成。Go 编程语言中 if 语句的语法如下：

if布尔表达式{
 /* 在布尔表达式为 true 时执行 */
}

If 在布尔表达式为 true 时，其后紧跟的语句块执行，如果为 false 则不执行。

实例：

packagemain
​
import"fmt"
​
funcmain() {
 varaint=20
ifa>20{
fmt.Println("a 大于20")
}
 fmt.Printf("a的值为： %d",a)
}

以上代码执行结果为：

a的值为： 20

if...else 语句

if 语句 后可以使用可选的 else 语句, else 语句中的表达式在布尔表达式为 false 时执行。

Go 编程语言中 if...else 语句的语法如下：

if布尔表达式{
 /* 在布尔表达式为 true 时执行 */
} else{
 /* 在布尔表达式为 false 时执行 */
}

If 在布尔表达式为 true 时，其后紧跟的语句块执行，如果为 false 则执行 else 语句块。

实例：

packagemain
​
import"fmt"
​
funcmain() {
 varaint=20
ifa>20{
fmt.Println("a 大于20")
}else{
fmt.Println("a 小于等于 20")
}
 fmt.Printf("a的值为： %d",a)
}

以上代码执行结果为：

a 小于等于 20
a的值为： 20

if 语句嵌套

你可以在 if 或 else if 语句中嵌入一个或多个 if 或 else if 语句。语法如下：

if布尔表达式1{
 /* 在布尔表达式 1 为 true 时执行 */
 if布尔表达式2{
 /* 在布尔表达式 2 为 true 时执行 */
 }
}

你可以以同样的方式在 if 语句中嵌套 else if...else 语句

实例：

packagemain
​
import"fmt"
​
funcmain() {
/* 定义局部变量 */
varaint=100
varbint=200
​
/* 判断条件 */
ifa==100{
/* if 条件语句为 true 执行 */
ifb==200{
/* if 条件语句为 true 执行 */
fmt.Printf("a 的值为 100 ， b 的值为 200\n");
}
}
fmt.Printf("a 值为 : %d\n", a);
fmt.Printf("b 值为 : %d\n", b);
}
 

以上代码执行结果为：

a 的值为 100 ， b 的值为 200
a 值为 : 100
b 值为 : 200

switch 语句

switch 语句用于基于不同条件执行不同动作，每一个 case 分支都是唯一的，从上直下逐一测试，直到匹配为止。。

switch 语句执行的过程从上至下，直到找到匹配项，匹配项后面也不需要再加break。

Go 编程语言中 switch 语句的语法如下：

switchvar1{
 caseval1:
 ...
 caseval2:
 ...
 default:
 ...
}

变量 var1 可以是任何类型，而 val1 和 val2 则可以是同类型的任意值。类型不被局限于常量或整数，但必须是相同的类型；或者最终结果为相同类型的表达式。

您可以同时测试多个可能符合条件的值，使用逗号分割它们，例如：case val1, val2, val3。

实例：

packagemain
​
import"fmt"
​
funcmain() {
vargradestring="B"
varmarksint=90
​
switchmarks{
case90:
grade="A"
case80:
grade="B"
case50,60,70:
grade="C"
default:
grade="D"
}
​
fmt.Println("grade==="+grade)
​
switch{
casegrade=="A":
fmt.Printf("优秀!\n")
casegrade=="B", grade=="C":
fmt.Printf("良好\n")
casegrade=="D":
fmt.Printf("及格\n")
casegrade=="F":
fmt.Printf("不及格\n")
default:
fmt.Printf("差\n");
}
fmt.Printf("你的等级是 %s\n", grade);
}
​

以上代码执行结果为：

grade===A
优秀!
你的等级是 A 

Type Switch

switch 语句还可以被用于 type-switch 来判断某个 interface 变量中实际存储的变量类型。

Type Switch 语法格式如下：

switchx.(type){
 casetype:
 statement(s); 
 casetype:
 statement(s); 
 /* 你可以定义任意个数的case */
 default: /* 可选 */
 statement(s);
}

实例：

packagemain
​
import"fmt"
​
funcmain() {
 varxinterface{}
 
 switchi:=x.(type) {
 casenil: 
 fmt.Printf(" x 的类型 :%T",i) 
 caseint: 
 fmt.Printf("x 是 int 型") 
 casefloat64:
 fmt.Printf("x 是 float64 型") 
 casefunc(int) float64:
 fmt.Printf("x 是 func(int) 型") 
 casebool, string:
 fmt.Printf("x 是 bool 或 string 型") 
 default:
 fmt.Printf("未知型") 
 }  

}

以上代码执行结果为：

x 的类型 :

select 语句

select是Go中的一个控制结构，类似于用于通信的switch语句。每个case必须是一个通信操作，要么是发送要么是接收。

select随机执行一个可运行的case。如果没有case可运行，它将阻塞，直到有case可运行。一个默认的子句应该总是可运行的。

Go 编程语言中 select 语句的语法如下：

select{
 casecommunicationclause:
 statement(s); 
 casecommunicationclause:
 statement(s); 
 /* 你可以定义任意数量的 case */
 default: /* 可选 */
 statement(s);
}

以下描述了 select 语句的语法：

• 每个case都必须是一个通信
• 所有channel表达式都会被求值
• 所有被发送的表达式都会被求值
• 如果任意某个通信可以进行，它就执行；其他被忽略。
• 如果有多个case都可以运行，Select会随机公平地选出一个执行。其他不会执行。
• 否则：

1. 如果有default子句，则执行该语句。
2. 如果没有default字句，select将阻塞，直到某个通信可以运行；Go不会重新对channel或值进行求值。

实例：

packagemain
​
import"fmt"
​
funcmain() {
 varc1, c2, c3chanint
 vari1, i2int
 select{
 casei1= fmt.Printf("received ", i1, " from c1\n")
 casec2 fmt.Printf("sent ", i2, " to c2\n")
 casei3, ok:=( ifok{
 fmt.Printf("received ", i3, " from c3\n")
 } else{
 fmt.Printf("c3 is closed\n")
 } 

 default:
 fmt.Printf("no communication\n")
 } 
}

以上代码执行结果为：

no communication

后续我们在go并发这一章节中将详细探讨select，现在大家只需要了解语法即可。

Go 语言循环语句

在不少实际问题中有许多具有规律性的重复操作，因此在程序中就需要重复执行某些语句。

Go 语言提供了以下几种类型循环处理语句：

循环控制语句

循环控制语句可以控制循环体内语句的执行过程。

GO 语言支持以下几种循环控制语句：

无限循环

如果循环中条件语句永远不为 false 则会进行无限循环，我们可以通过 for 循环语句中只设置一个条件表达式来执行无限循环：

packagemain
​
import"fmt"
​
funcmain() {
 fortrue{
 fmt.Printf("这是无限循环。\n");
 }
}

for 循环

for循环是一个循环控制结构，可以执行指定次数的循环。

Go语言的For循环有3中形式，只有其中的一种使用分号。

和 C 语言的 for 一样：

for init; condition; post { }

和 C 的 while 一样：

for condition { }

和 C 的 for(;;) 一样：

for { }

• init： 一般为赋值表达式，给控制变量赋初值；
• condition： 关系表达式或逻辑表达式，循环控制条件；
• post： 一般为赋值表达式，给控制变量增量或减量。

for语句执行过程如下：

①先对表达式1赋初值；

②判别赋值表达式 init 是否满足给定条件，若其值为真，满足循环条件，则执行循环体内语句，然后执行 post，进入第二次循环，再判别 condition；否则判断 condition 的值为假，不满足条件，就终止for循环，执行循环体外语句。

for 循环的 range 格式可以对 slice、map、数组、字符串等进行迭代循环。格式如下：

forkey, value:=rangeoldMap{
 newMap[key] =value
}

for语句语法流程如下图所示：

实例：

packagemain
​
import"fmt"
​
funcmain(){
numbers:=[6]int{1,2,3,4,5}
​
varaint
varbint=15
​
fora:=0;a<10; a++{
fmt.Printf("a 的值为: %d\n", a)
}
​
foraa++;
fmt.Printf("a 的值为: %d\n", a)
}
​
fori,x:=rangenumbers{
fmt.Printf("第 %d 位 x 的值 = %d\n", i,x)
}
​
}
​

以上实例运行输出结果为:

a 的值为: 0
a 的值为: 1
a 的值为: 2
a 的值为: 3
a 的值为: 4
a 的值为: 5
a 的值为: 6
a 的值为: 7
a 的值为: 8
a 的值为: 9
a 的值为: 1 

a 的值为: 2
a 的值为: 3
a 的值为: 4
a 的值为: 5
a 的值为: 6
a 的值为: 7
a 的值为: 8
a 的值为: 9
a 的值为: 10
a 的值为: 11
a 的值为: 12
a 的值为: 13
a 的值为: 14
a 的值为: 15
第 0 位 x 的值 = 1
第 1 位 x 的值 = 2
第 2 位 x 的值 = 3
第 3 位 x 的值 = 4
第 4 位 x 的值 = 5
第 5 位 x 的值 = 0

for 循环嵌套

Go 语言允许用户在循环内使用循环。接下来我们将为大家介绍嵌套循环的使用。

以下为 Go 语言嵌套循环的格式：

for[condition|( init; condition; increment) |Range]
{
 for[condition|( init; condition; increment) |Range]
 {
 statement(s);
 }
 statement(s);
}
 

实例：

以下实例使用循环嵌套来输出 2 到 100 间的素数：

packagemain
​
import"fmt"
​
funcmain() {
 /* 定义局部变量 */
 vari, jint
​
 fori=2; i<100; i++{
 forj=2; j<=(i/j); j++{
 if(i%j==0) {
 break; // 如果发现因子，则不是素数
 }
 }
 if(j>(i/j)) {
 fmt.Printf("%d 是素数\n", i);
 }
 } 
}

以上实例运行输出结果为:

2 是素数
3 是素数
5 是素数
7 是素数
11 是素数
13 是素数
17 是素数
19 是素数
23 是素数
29 是素数
31 是素数
37 是素数
41 是素数 

43 是素数
47 是素数
53 是素数
59 是素数
61 是素数
67 是素数
71 是素数
73 是素数
79 是素数
83 是素数
89 是素数
97 是素数

break 语句

Go 语言中 break 语句用于以下两方面：

1. 用于循环语句中跳出循环，并开始执行循环之后的语句。
2. break在switch（开关语句）中在执行一条case后跳出语句的作用。

break 语法格式如下：

break;

实例：

packagemain
​
import"fmt"
​
funcmain() {
 /* 定义局部变量 */ 

 varaint=10
​
 /* for 循环 */
 fora<20{
 fmt.Printf("a 的值为 : %d\n", a);
 a++;
 ifa>15{
 /* 使用 break 语句跳出循环 */
 break;
 }
 }
}

以上实例执行结果为：

a 的值为 : 10
a 的值为 : 11
a 的值为 : 12
a 的值为 : 13
a 的值为 : 14
a 的值为 : 15

continue 语句

Go 语言的 continue 语句 有点像 break 语句。但是 continue 不是跳出循环，而是跳过当前循环执行下一次循环语句。

for 循环中，执行 continue 语句会触发for增量语句的执行。

continue 语法格式如下：

continue;

实例：

packagemain
​
import"fmt"
​
funcmain() {
 /* 定义局部变量 */
 varaint=10
​
 /* for 循环 */
 fora<20{
 ifa==15{
 /* 跳过此次循环 */
 a=a+1;
 continue;
 }
 fmt.Printf("a 的值为 : %d\n", a);
 a++; 
 } 
}

以上实例执行结果为：

a 的值为 : 10
a 的值为 : 11
a 的值为 : 12
a 的值为 : 13
a 的值为 : 14
a 的值为 : 16
a 的值为 : 17
a 的值为 : 18
a 的值为 : 19

goto 语句

Go 语言的 goto 语句可以无条件地转移到过程中指定的行。

goto语句通常与条件语句配合使用。可用来实现条件转移， 构成循环，跳出循环体等功能。

但是，在结构化程序设计中一般不主张使用goto语句， 以免造成程序流程的混乱，使理解和调试程序都产生困难。

goto 语法格式如下：

gotolabel;
..
.
label: statement;

实例：

packagemain
​
import"fmt"
​
funcmain() {
 /* 定义局部变量 */
 varaint=10
​
 /* 循环 */
 LOOP: fora<20{
 ifa==15{
 /* 跳过迭代 */
 a=a+1
 gotoLOOP
 }
 fmt.Printf("a的值为 : %d\n", a)
 a++ 
 } 
}

以上实例执行结果为：

a的值为 : 10
a的值为 : 11
a的值为 : 12
a的值为 : 13
a的值为 : 14 

a的值为 : 16
a的值为 : 17
a的值为 : 18
a的值为 : 19

閱讀更多 科技伍小黑 的文章

關鍵字: 条件 语句 编程语言