Di GO, penggunaan suis jenis (jenis suis) adalah kaedah idiomatik untuk menentukan jenis nilai antara muka tertentu yang mendasari. Ia dilaksanakan melalui Switch V: = i. (Jenis) Sintaks, dan boleh melaksanakan logik yang sepadan mengikut jenis sepadan yang berbeza. Ia sesuai untuk mengendalikan senario cawangan pelbagai jenis antara muka {} jenis, seperti parsing JSON atau debugging log. V dalam setiap kes adalah jenis khusus yang sepadan dan bertindak dalam blok kes. Ia hanya melaksanakan lalai apabila tidak ada perlawanan, dan menyokong penghakiman yang jelas. Ia lebih jelas dan lebih cekap daripada pelbagai jenis pernyataan, tetapi penggunaan yang berlebihan harus dielakkan untuk memastikan reka bentuk kod ringkas.

Di GO, antara muka digunakan untuk menentukan tingkah laku tanpa menentukan pelaksanaan. Apabila anda mempunyai nilai antara muka, anda mungkin perlu menentukan jenis konkrit yang mendasari semasa runtime. Suis jenis adalah cara idiomatik untuk melakukan ini.

Suis jenis membolehkan anda membandingkan jenis dinamik nilai antara muka terhadap beberapa jenis dan melaksanakan logik yang berbeza bergantung pada jenis yang sepadan.

Sintaks suis jenis

Bentuk umum suis jenis kelihatan seperti ini:

 suis v: = i. (jenis) {
Kes T1:
    // v mempunyai jenis t1
Kes T2:
    // v mempunyai jenis t2
Lalai:
    // tiada perlawanan; v mempunyai jenis yang sama seperti saya, atau tidak
}

Di sini, i adalah interface{} (atau mana -mana antara muka), dan v mengambil nilai i membuang ke jenis konkrit yang sepadan dalam setiap kes.

Contoh: Menggunakan Switch Type pada antara muka

Katakan anda mempunyai fungsi yang menerima apa -apa jenis melalui interface{} dan ingin mengendalikan jenis yang berbeza secara berbeza:

 Pakej utama

Import "FMT"

Func Huraikan (I Interface {}) {
    suis v: = i. (jenis) {
    kes int:
        fmt.printf ("Integer: %d \ n", v)
    rentetan kes:
        fmt.printf ("String: %s \ n", v)
    kes bool:
        fmt.printf ("Boolean: %t \ n", v)
    Lalai:
        fmt.printf ("Jenis yang tidak diketahui: %t \ n", v)
    }
}

func main () {
    Huraikan (42)
    Huraikan ("Hello")
    Huraikan (benar)
    Huraikan (3.14)
}

Output:

 Integer: 42
String: Helo
Boolean: Benar
Jenis yang tidak diketahui: Float64

Dalam contoh ini:

• Variabel v di dalam setiap case adalah nilai i dengan jenis konkritnya.
• Kes default berjalan apabila tiada jenis yang disenaraikan.
• Kata kerja %T dalam fmt.Printf mencetak jenis sebenar.

Bila Menggunakan Suis Jenis

Anda harus menggunakan suis jenis apabila:

• Anda bekerja dengan kod seperti generik sebelum pergi 1.18 (atau dalam konteks di mana generik tidak sesuai).
• Anda menyahkod data (contohnya, dari JSON) ke dalam map[string]interface{} dan perlu memeriksa jenis bersarang.
• Anda menulis alat middleware, pembalakan, atau debugging yang mengendalikan nilai sewenang -wenangnya.

Sebagai contoh, memproses JSON:

 data: = peta [string] antara muka {} {
    "Nama": "Alice",
    "Umur": 30,
    "Aktif": Benar,
}

untuk k, v: = data julat {
    suis val: = v. (jenis) {
    rentetan kes:
        fmt.printf (" %s adalah rentetan: %s \ n", k, val)
    kes int:
        fmt.printf (" %s adalah int: %d \ n", k, val)
    kes bool:
        fmt.printf (" %s adalah bool: %t \ n", k, val)
    Lalai:
        fmt.printf (" %s mempunyai jenis yang tidak diketahui %t \ n", k, val)
    }
}

Nota penting

• Anda tidak boleh menggunakan suis jenis pada jenis bukan antara muka. Ungkapan mestilah jenis antara muka.
• Hanya satu kes yang akan dilaksanakan - yang sepadan pertama.
• v dalam setiap kes dilengkapkan ke blok kes itu dan mempunyai jenis konkrit.
• Jika antara muka memegang nilai nil , kes default berjalan (melainkan jika anda mempunyai case nil: .

Anda juga boleh menyemak nil secara eksplisit:

 suis v: = i. (jenis) {
kes nil:
    fmt.println ("Nil Interface")
kes int:
    fmt.println ("Integer:", v)
Lalai:
    fmt.printf ("Jenis lain: %t", v)
}

Alternatif: Taipkan penegasan (cek tunggal)

Jika anda hanya mengharapkan satu jenis, penegasan jenis mudah mungkin lebih baik:

 jika v, ok: = i. (int); ok {
    fmt.println ("Ini int:", v)
}

Tetapi jika anda menyemak pelbagai jenis yang mungkin, suis jenis adalah lebih bersih dan lebih cekap.

Pada asasnya, suis jenis adalah cara yang paling berkesan untuk mengendalikan pelbagai jenis yang mungkin dan bersih yang disimpan dalam antara muka. Ingatlah untuk menggunakannya dengan bijak - terlalu banyak boleh menjadi tanda bahawa reka bentuk anda mungkin mendapat manfaat daripada abstraksi yang lebih baik atau, dalam pergi moden, generik.

Atas ialah kandungan terperinci Cara menggunakan suis jenis pada antara muka di Go. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!