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

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

關鍵字: 條件 語句 編程語言