Go 語言條件語句
條件語句需要開發者通過指定一個或多個條件，並通過測試條件是否為 true 來決定是否執行指定語句，並在條件為 false 的情況在執行另外的語句。
Go 語言提供了以下幾種條件判斷語句：
|
語句
|
描述
|
|
if 語句 由一個布林表示式後緊跟一個或多個語句組成。
|
|
|
if 語句 後可以使用可選的 else 語句, else 語句中的表示式在布林表示式為 false 時執行。
|
|
|
你可以在 if 或 else if 語句中嵌入一個或多個 if 或 else if 語句。
|
|
|
switch 語句用於基於不同條件執行不同動作。
|
|
|
select 語句類似於 switch 語句，但是select會隨機執行一個可執行的case。如果沒有case可執行，它將阻塞，直到有case可執行。
|
Go語言if語句
if 語句由布林表示式後緊跟一個或多個語句組成。
語法
Go 程式語言中 if 語句的語法如下：
if 布林表示式 { /* 在布林表示式為 true 時執行 */ }
If 在布林表示式為 true 時，其後緊跟的語句塊執行，如果為 false 則不執行。
例項
使用 if 判斷一個數變數的大小：
例項
package main
import "fmt"
func main() {
/* 定義區域性變數 */
var a int = 10
/* 使用 if 語句判斷布林表示式 */
if a < 20 {
/* 如果條件為 true 則執行以下語句 */
fmt.Printf("a 小於 20\n" )
}
fmt.Printf("a 的值為 : %d\n", a)
}
以上程式碼執行結果為：
a 小於 20 a 的值為 : 10
Go 語言 if...else 語句
if 語句 後可以使用可選的 else 語句, else 語句中的表示式在布林表示式為 false 時執行。
語法
Go 程式語言中 if...else 語句的語法如下：
if 布林表示式 { /* 在布林表示式為 true 時執行 */ } else { /* 在布林表示式為 false 時執行 */ }
If 在布林表示式為 true 時，其後緊跟的語句塊執行，如果為 false 則執行 else 語句塊。
例項
使用 if else 判斷一個數的大小：
例項
package main
import "fmt"
func main() {
/* 區域性變數定義 */
var a int = 100;
/* 判斷布林表示式 */
if a < 20 {
/* 如果條件為 true 則執行以下語句 */
fmt.Printf("a 小於 20\n" );
} else {
/* 如果條件為 false 則執行以下語句 */
fmt.Printf("a 不小於 20\n" );
}
fmt.Printf("a 的值為 : %d\n", a);
}
以上程式碼執行結果為：
a 不小於 20 a 的值為 : 100
Go 語言 if 語句巢狀
你可以在 if 或 else if 語句中嵌入一個或多個 if 或 else if 語句。
語法
Go 程式語言中 if...else 語句的語法如下：
if 布林表示式 1 { /* 在布林表示式 1 為 true 時執行 */ if 布林表示式 2 { /* 在布林表示式 2 為 true 時執行 */ } }
你可以以同樣的方式在 if 語句中巢狀 else if...else 語句
例項
巢狀使用 if 語句：
例項
package main
import "fmt"
func main() {
/* 定義區域性變數 */
var a int = 100
var b int = 200
/* 判斷條件 */
if a == 100 {
/* if 條件語句為 true 執行 */
if b == 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
Go 語言 switch 語句
switch 語句用於基於不同條件執行不同動作，每一個 case 分支都是唯一的，從上至下逐一測試，直到匹配為止。
switch 語句執行的過程從上至下，直到找到匹配項，匹配項後面也不需要再加 break。
switch 預設情況下 case 最後自帶 break 語句，匹配成功後就不會執行其他 case，如果我們需要執行後面的 case，可以使用 fallthrough 。
語法
Go 程式語言中 switch 語句的語法如下：
switch var1 { case val1: ... case val2: ... default: ... }
變數 var1 可以是任何型別，而 val1 和 val2 則可以是同型別的任意值。型別不被侷限於常量或整數，但必須是相同的型別；或者最終結果為相同型別的表示式。
您可以同時測試多個可能符合條件的值，使用逗號分割它們，例如：case val1, val2, val3。
流程圖：
例項
package main
import "fmt"
func main() {
/* 定義區域性變數 */
var grade string = "B"
var marks int = 90
switch marks {
case 90: grade = "A"
case 80: grade = "B"
case 50,60,70 : grade = "C"
default: grade = "D"
}
switch {
case grade == "A" :
fmt.Printf("優秀!\n" )
case grade == "B", grade == "C" :
fmt.Printf("良好\n" )
case grade == "D" :
fmt.Printf("及格\n" )
case grade == "F":
fmt.Printf("不及格\n" )
default:
fmt.Printf("差\n" );
}
fmt.Printf("你的等級是 %s\n", grade );
}
以上程式碼執行結果為：
優秀! 你的等級是 A
Type Switch
switch 語句還可以被用於 type-switch 來判斷某個 interface 變數中實際儲存的變數型別。
Type Switch 語法格式如下：
switch x.(type){ case type: statement(s); case type: statement(s); /* 你可以定義任意個數的case */ default: /* 可選 */ statement(s); }
例項
package main
import "fmt"
func main() {
var x interface{}
switch i := x.(type) {
case nil:
fmt.Printf(" x 的型別 :%T",i)
case int:
fmt.Printf("x 是 int 型")
case float64:
fmt.Printf("x 是 float64 型")
case func(int) float64:
fmt.Printf("x 是 func(int) 型")
case bool, string:
fmt.Printf("x 是 bool 或 string 型" )
default:
fmt.Printf("未知型")
}
}
以上程式碼執行結果為：
x 的型別 :<nil>
fallthrough
使用 fallthrough 會強制執行後面的 case 語句，fallthrough 不會判斷下一條 case 的表示式結果是否為 true。
例項
package main
import "fmt"
func main() {
switch {
case false:
fmt.Println("1、case 條件語句為 false")
fallthrough
case true:
fmt.Println("2、case 條件語句為 true")
fallthrough
case false:
fmt.Println("3、case 條件語句為 false")
fallthrough
case true:
fmt.Println("4、case 條件語句為 true")
case false:
fmt.Println("5、case 條件語句為 false")
fallthrough
default:
fmt.Println("6、預設 case")
}
}
以上程式碼執行結果為：
2、case 條件語句為 true 3、case 條件語句為 false 4、case 條件語句為 true
從以上程式碼輸出的結果可以看出：switch 從第一個判斷表示式為 true 的 case 開始執行，如果 case 帶有 fallthrough，程式會繼續執行下一條 case，且它不會去判斷下一個 case 的表示式是否為 true。
Go 語言 select 語句
select 是 Go 中的一個控制結構，類似於用於通訊的 switch 語句。每個 case 必須是一個通訊操作，要麼是傳送要麼是接收。
select 隨機執行一個可執行的 case。如果沒有 case 可執行，它將阻塞，直到有 case 可執行。一個預設的子句應該總是可執行的。
語法
Go 程式語言中 select 語句的語法如下：
select {
case communication clause :
statement(s);
case communication clause :
statement(s);
/* 你可以定義任意數量的 case */
default : /* 可選 */
statement(s);
}
以下描述了 select 語句的語法：
- 每個 case 都必須是一個通訊
- 所有 channel 表示式都會被求值
- 所有被髮送的表示式都會被求值
- 如果任意某個通訊可以進行，它就執行，其他被忽略。
- 如果有多個 case 都可以執行，Select 會隨機公平地選出一個執行。其他不會執行。
否則：
- 如果有 default 子句，則執行該語句。
- 如果沒有 default 子句，select 將阻塞，直到某個通訊可以執行；Go 不會重新對 channel 或值進行求值。
例項
select 語句應用演示：
例項
package main
import "fmt"
func main() {
var c1, c2, c3 chan int
var i1, i2 int
select {
case i1 = <-c1:
fmt.Printf("received ", i1, " from c1\n")
case c2 <- i2:
fmt.Printf("sent ", i2, " to c2\n")
case i3, ok := (<-c3): // same as: i3, ok := <-c3
if ok {
fmt.Printf("received ", i3, " from c3\n")
} else {
fmt.Printf("c3 is closed\n")
}
default:
fmt.Printf("no communication\n")
}
}
以上程式碼執行結果為：
no communication
//校內舉辦跑步比賽，10s內進去比賽，分性別，進入男子組，女子組
package main
import "fmt"
//if語句巢狀
//校內舉辦跑步比賽，10s內進去比賽，分性別，進入男子組，女子組
func main() {
var (
a = 9
b = "男"
)
if a < 10 && b == "男" {
fmt.Println("進去決賽")
fmt.Println("進入男子")
}
if a < 10 && b == "女" {
fmt.Println("進去決賽")
fmt.Println("進入女子組")
}
if a > 10 {
fmt.Println("滾")
}
/*
if a < 10 {
fmt.Println("進去決賽")
if b == "男" {
fmt.Println("進入男子")
} else {
fmt.Println("進入女子")
}
} else {
fmt.Println("滾")
}*/
}
//switch語句，對學生成績進行考評，90-100：優秀，80-89：良好，60-79及格，60以下，不及格
package main
import "fmt"
func main() {
var vaule = 1
switch vaule {
case 1:
fmt.Println("1")
case 2:
fmt.Println("2")
case 3:
fmt.Println("3")
default:
fmt.Println("滾犢子")
}
/*
var a = 77
//等效於if else 語句
switch {
case a >= 90 && a <= 100:
fmt.Println("好")
case a >= 80 && a <= 89:
fmt.Println("還行")
case a >= 60 && a <= 79:
fmt.Println("合格")
default:
fmt.Println("不合格")
}*/
}