Go以其簡潔而著稱，但并不是每個人都熟悉這種語言中switch語句的多樣性。首先，如果你對Go的switch語句還不熟悉，它可能與其他語言相比有些不同。

下面是一個簡單的示例來展示它是什么樣子的：

func main() {
    var i int = 1

    switch i {
        case 1:
        fmt.Println("i is 1")
        case 2:
        fmt.Println("i is 2")
        default:
        fmt.Println("i is not 1 or 2")
    }
}

Go的switch語句有一個很酷的特性，即在找到匹配項后就會停止執(zhí)行，不需要在每個case的末尾加上break語句。

在Go的switch語句中有兩個部分：分號前的部分是初始化器，分號后的部分是要檢查的值。

可以選擇使用兩個部分、其中一個部分或者都不使用：

switch initializer; value {}

switch initializer {}

switch value {}

switch {}

很有趣，是吧？

使用字面布爾值的switch

有時候，可能會使用一個變量的switch語句，但這里有一種不同的方法。

考慮使用一個帶有字面布爾值的switch語句。這種方法可以讓我們檢查多個條件，而不僅僅局限于一個變量的值。

func main() {
    var a int = 1
    var b int = 2

    switch true { // <--- use true literal
        case a == 1 && b == 2:
        fmt.Println("a is 1 and b is 2")
        case a == 3:
        fmt.Println("a is 3"):
        default:
        fmt.Println("a is not 1 or 3")
    }
}

乍一看，switch true可能似乎是多余和無意義的。

它感覺有點像在陳述顯而易見的事實，但好消息是Go有一種更簡化的處理方式，可以像這樣簡化它：

switch { // <--- just remove `true`
    case a == 1 && b == 2:
    ...
}

這種簡化的方法同樣有效。

另外，switch語句也可以與false字面值一起使用，提供了一種確定哪些條件未滿足的方法。

Switch短賦值

我們經常忽視switch語句中的初始化器部分。

但它非常有用，與if語句或for循環(huán)中的初始化器類似。它允許你聲明并賦值一個變量，然后立即使用它。

下面是一個例子來說明這一點：

switch a := 1; a {
    case 1:
    fmt.Println("a is 1")
}

// similar
if a := 1; a == 1 {
    fmt.Println("a is 1")
}

在這些情況下，變量a的作用域僅限于switch語句，意味著不能在外部使用a。

還記得我們可以忽略switch的兩個部分嗎？

你也可以選擇只使用初始化器部分，當你這樣做時，值部分被假定為true：

switch a := 1 {
    case a == 1:
    fmt.Println("a is 1")
    case a == 2:
    fmt.Println("a is 2")
}

到目前為止，我們已經看到了四種組織switch語句的方式：只使用初始化器、只使用值、兩者都使用或者兩者都不使用。但我們的重點主要在于switch本身。

接下來，我們將深入探討case部分的作用以及如何在代碼中充分利用它。

包含多個值的case

你可以在一個case中組合多個值。這種方法可以使你的代碼更簡潔易讀：

switch a := 1; a {
    case 1, 2, 3: // <--
    fmt.Println("a is 1, 2 or 3")
}

很多Go的新手并不知道這個功能。相反，他們可能會寫出這樣的代碼：

switch a := 1; a {
    case 1:
case 2:
case 3:
    fmt.Println("a is 1, 2 or 3")
}

但這種方法并不完全正確，因為switch在Go中的工作方式不同。

在這個例子中，打印語句只與最后一個case（case 3）相關聯(lián)。所以，如果a是1或2，什么也不會發(fā)生，因為這些case后面沒有指令，程序會直接跳過它們。

使用fallthrough關鍵字的case

這個關鍵字允許執(zhí)行繼續(xù)到下一個case而不檢查其條件。這與大多數語言處理switch case的方式有些不同。

下面是一個例子來展示fallthrough的工作方式：

switch a := 1; a {
    case 1:
    fmt.Println("a is 1")
    fallthrough
    case 2:
    fmt.Println("Now in case 2")
    default:
    fmt.Println("Neither 1 nor 2")
}

輸出會是什么？

在這種情況下，當a為1時，程序首先打印“a is 1”。然后，由于fallthrough關鍵字的存在，它會立即跳轉到下一個case（case 2），而不檢查a是否實際上為2。所以，它也會打印出“Now in case 2”。

你仍然可以在case 2中使用fallthrough關鍵字，程序會繼續(xù)執(zhí)行下一個case（default），并打印“Neither 1 nor 2”。

switch a := 1; a {
    case 1:
    fmt.Println("a is 1")
    fallthrough
    case 2:
    fmt.Println("Now in case 2")
    fallthrough
    default:
    fmt.Println("Neither 1 nor 2")
}

// Output:
// a is 1
// Now in case 2
// Neither 1 nor 2

但要記住，在Go中，fallthrough關鍵字繞過了下一個case的條件檢查。因此，在switch語句的最后一個case中不使用它，因為沒有后續(xù)的case可以過渡到。

默認情況和其細微差別

Go中的switch語句的默認情況類似于if語句中的else部分。

當沒有任何其他case匹配時，它將執(zhí)行默認情況，但是在Go中，默認情況有一些有趣的特點：

盡管在大多數編程語言中，默認情況通常放在末尾，但在Go中，它可以放置在switch語句的任何位置。大多數人為了清晰起見會把它放在末尾，但讓我們看看當我們把它放在開頭時會發(fā)生什么：

switch a := 1; a {
    default:
    fmt.Println("Neither 1 nor 2")
    case 1:
    fmt.Println("a is 1")
    case 2:
    fmt.Println("Now in case 2")
}

在這個例子中，即使默認情況首先出現，它仍然被視為最后的選擇，只有在沒有其他case匹配時才會執(zhí)行。

但還有另一層可以探索。

如果我們將默認情況與fallthrough關鍵字混合使用會怎么樣？讓我們來看看：

switch a := 3; a {
    default:
    fmt.Println("Neither 1 nor 2")
    fallthrough
    case 1:
    fmt.Println("a is 1")
    case 2:
    fmt.Println("Now in case 2")
}

// Output:
// Neither 1 nor 2
// a is 1

在這種情況下，當a為3時，switch從默認情況開始，打印“Neither 1 nor 2”。然后，由于fallthrough的存在，它會移動到下一個case，打印“a is 1”。

帶有類型斷言的switch

switch語句不僅可以處理值，還可以處理類型。這在處理接口時特別有用。

類型斷言是實現這一功能的特性，它允許檢查接口值的類型，并根據該類型運行不同的代碼段：

func main() {
    var i interface{} = "hello"

    switch v := i.(type) {
        case int:
        fmt.Println("i is an int and its value is", v)
        case string:
        fmt.Println("i is a string and its value is", v)
        default:
        fmt.Println("Unknown type")
    }
}

在這種情況下，i是一個存儲字符串的接口變量。

switch語句使用i.(type)來確定i的類型，然后根據該類型選擇要執(zhí)行的case：

• 它逐個檢查每個case是否為特定類型（如int或string）。
• 在每個case中，v表示i作為該case中檢查的類型的值，因此可以像使用該類型的任何變量一樣使用v。