Ketik saklar

Saklar tipe membedakan beberapa kemungkinan tipe dari sebuah nilai antarmuka. Ini adalah generalisasi dari comma ok padahal ada lebih dari satu kasus.

Sintaksis

func describe(i interface{}) string {
    switch v := i.(type) {
    case int:
        return fmt.Sprintf("int %d", v)
    case string:
        return fmt.Sprintf("string %q", v)
    case nil:
        return "nil"
    default:
        return fmt.Sprintf("altro tipo: %T", v)
    }
}

• i.(type) adalah sintaks khusus, HANYA valid di dalam switch.
• v := ... mengikat nilai dengan tipe kasus saat ini: di dalam case int, v memiliki tipe int.
• default menangkap semua jenis lainnya; di sana v memiliki tipe antarmuka asli.
• case nil cocok dengan antarmuka dengan tipe dinamis nihil.

Kasus "Tanpa Nama".

Jika Anda tidak memerlukan nilai yang diketik, Anda dapat menghilangkan v:

switch i.(type) {
case int:
    // you know it's an int, but you don't have a variable of that type
case string:
    // ...
}

Formulir yang digunakan ketika Anda hanya perlu membedakan jenisnya, bukan pengoperasiannya pada nilainya.

Beberapa jenis dalam kasus yang sama

switch v := i.(type) {
case int, int64:
    // here v is still interface{}: the "common" type is just the interface
    fmt.Println("numero intero:", v)
case string:
    // here v is string
    fmt.Println("stringa:", v)
}

Kasus penggunaan umum: pencetakan berformat

func print(i interface{}) {
    switch v := i.(type) {
    case int:
        fmt.Printf("%d\n", v)
    case string:
        fmt.Printf("%s\n", v)
    case fmt.Stringer:
        fmt.Println(v.String())
    default:
        fmt.Printf("%v\n", v)
    }
}

fmt.Println sendiri menggunakan saklar tipe secara internal untuk menanganinya format standar.

Ketik saklar vs refleksi

Untuk beberapa tipe yang diketahui → ketik switch (cepat, mudah dibaca). Untuk inspeksi dinamis dari tipe yang tidak diketahui → paket reflect (selengkapnya kuat tetapi lebih lambat dan lebih bertele-tele).

Cobalah

switch ??? {
  case int: ...
}

Rekap

• switch v := i.(type) { case T: ... }: membedakan tipe dinamis.
• Di dalam case tipe tunggal, v memiliki tipe case.
• case T1, T2: v mempertahankan tipe antarmuka asli.
• default untuk kasus yang tidak tertangani; case nil untuk antarmuka nihil.
• Tidak ada fallthrough pada sakelar tipe.
• 1 tipe → ketik pernyataan; 2+ tipe → tipe sakelar.