Go言語のcase文の使い方について解説

package main
import "fmt"
func main() {
    num := 2  // 数値データの例
    switch num {
    case 1:
        fmt.Println("数値は1です")
    case 2:
        fmt.Println("数値は2です")
    default:
        fmt.Println("1とも2とも一致しません")
    }
}

数値は2です

package main
import "fmt"
func main() {
    color := "blue"  // 色情報の例
    switch color {
    case "red", "blue", "yellow":
        // red, blue, yellowのいずれかの場合にこの処理が実行されます
        fmt.Println("指定された色は主要色の一つです")
    default:
        fmt.Println("主要色ではありません")
    }
}

指定された色は主要色の一つです

package main
import "fmt"
func main() {
    score := 85  // 成績の例
    switch {
    case score >= 90:
        fmt.Println("優秀です")
    case score >= 70:
        // scoreが70以上90未満の場合の処理です
        fmt.Println("良好です")
    default:
        fmt.Println("改善の余地があります")
    }
}

良好です

package main
import "fmt"
func main() {
    day := "土曜日"  // 曜日の例
    switch day {
    case "月曜日", "火曜日", "水曜日", "木曜日", "金曜日":
        fmt.Println("平日です")
    default:
        // 曜日が上記に含まれない場合の処理です
        fmt.Println("週末または特別な日です")
    }
}

週末または特別な日です

package main
import "fmt"
// 引数の型を判定して、各型ごとに処理を分岐する関数です
func identifyType(value interface{}) {
    switch v := value.(type) {
    case int:
        fmt.Println("整数型であり、値は", v)
    case string:
        fmt.Println("文字列型であり、値は", v)
    case bool:
        fmt.Println("ブール型であり、値は", v)
    default:
        fmt.Println("その他の型です")
    }
}
func main() {
    identifyType(100)
    identifyType("Go言語")
    identifyType(true)
}

整数型であり、値は 100
文字列型であり、値は Go言語
ブール型であり、値は true

package main
import "fmt"
func printType(value interface{}) {
    // 型スイッチにより、値の型を実行時に判断します
    switch v := value.(type) {
    case int:
        fmt.Println("処理対象は整数型で、値は", v)
    case float64:
        fmt.Println("処理対象は浮動小数点型で、値は", v)
    default:
        fmt.Println("処理対象はその他の型です")
    }
}
func main() {
    printType(42)
    printType(3.1415)
    printType("サンプル")
}

処理対象は整数型で、値は 42
処理対象は浮動小数点型で、値は 3.1415
処理対象はその他の型です

package main
import (
    "errors"
    "fmt"
)
// カスタムエラー型の定義
type CustomError struct {
    Message string
}
func (e CustomError) Error() string {
    return e.Message
}
// エラーの種類に応じた処理を行う関数です
func handleError(err error) {
    switch e := err.(type) {
    case CustomError:
        fmt.Println("カスタムエラー発生:", e.Message)
    case *CustomError:
        fmt.Println("ポインタ型のカスタムエラー発生:", e.Message)
    default:
        fmt.Println("一般的なエラー発生:", e.Error())
    }
}
func main() {
    err1 := CustomError{Message: "サンプルのカスタムエラー"}
    err2 := errors.New("標準エラーです")
    handleError(err1)
    handleError(err2)
}

カスタムエラー発生: サンプルのカスタムエラー
一般的なエラー発生: 標準エラーです

package main
import "fmt"
func main() {
    status := 1  // 状態を表す数値
    switch status {
    case 0:
        fmt.Println("状態は0です")
    case 1:
        fmt.Println("状態は1です")
    case 2:
        fmt.Println("状態は2です")
    default:
        fmt.Println("予期しない状態です")
    }
}

状態は1です

package main
import "fmt"
func main() {
    level := "中級"  // 技術レベルの例
    switch level {
    case "初級", "中級":
        fmt.Println("学習を継続中です")
    case "上級":
        fmt.Println("さらなる高みを目指しています")
    default:
        fmt.Println("不明なレベルです")
    }
}

学習を継続中です

package main
import "fmt"
// 数値に応じて異なるメッセージを出力する関数です
func analyzeNumber(num int) {
    // 条件式をswitch自体に記述することで、柔軟な分岐を実現できます
    switch {
    case num < 0:
        fmt.Println("負の値です")
    case num == 0:
        fmt.Println("ゼロです")
    case num > 0 && num < 10:
        fmt.Println("一桁の正の数です")
    default:
        fmt.Println("大きな正の数です")
    }
}
func main() {
    analyzeNumber(-5)
    analyzeNumber(0)
    analyzeNumber(7)
    analyzeNumber(15)
}

負の値です
ゼロです
一桁の正の数です
大きな正の数です

package main
import "fmt"
// 値を受け取り、その型に応じた処理を行う関数です
func processValue(val interface{}) {
    switch v := val.(type) {
    case int:
        fmt.Println("整数型の値:", v)
    case float64:
        fmt.Println("浮動小数点型の値:", v)
    case string:
        fmt.Println("文字列型の値:", v)
    default:
        fmt.Println("未知の型")
    }
}
func main() {
    processValue(25)
    processValue(3.14)
    processValue("Go言語")
}

整数型の値: 25
浮動小数点型の値: 3.14
文字列型の値: Go言語