Apakah penegasan jenis dalam bahasa go?

Dalam bahasa Go, penegasan jenis ialah operasi yang digunakan pada nilai antara muka Ia digunakan untuk menyemak sama ada nilai yang dipegang oleh pembolehubah jenis antara muka melaksanakan antara muka yang dijangkakan atau jenis tertentu := x.(T)". Apa yang boleh dilakukan melalui penegasan jenis: 1. Semak sama ada i adalah nil 2. Semak sama ada nilai yang disimpan dalam i adalah daripada jenis tertentu.

Persekitaran pengendalian tutorial ini: sistem Windows 7, GO versi 1.18, komputer Dell G3.

Apakah penegasan?

Penegasan ialah istilah pengaturcaraan yang dinyatakan sebagai beberapa ungkapan Boolean. Apabila menulis kod, kami sentiasa membuat beberapa andaian, dan penegasan digunakan untuk menangkap andaian ini dalam kod. Untuk memahami penegasan, ia bermakna penghakiman. Jadi dalam Go, kita boleh memahami penegasan jenis sebagai pertimbangan jenis.

Pengenalan kepada Type Assertion

Type Assertion ialah operasi yang digunakan pada nilai antara muka untuk menyemak sama ada nilai yang dipegang oleh pembolehubah jenis antara muka dilaksanakan Antara muka yang dikehendaki atau jenis tertentu.

Format sintaks bagi penegasan jenis dalam bahasa Go adalah seperti berikut:

value, ok := x.(T)

Di mana, x mewakili jenis antara muka, dan T mewakili jenis tertentu (juga boleh menjadi antara muka jenis).

Ungkapan penegasan ini akan mengembalikan nilai x (iaitu, nilai) dan nilai Boolean (iaitu, ok, ia boleh dinilai sama ada x jenis T: <). 🎜>

• Jika T ialah jenis tertentu, penegasan jenis akan menyemak sama ada jenis dinamik x adalah sama dengan jenis T tertentu. Jika semakan berjaya, penegasan jenis mengembalikan nilai dinamik x yang jenisnya ialah T.

• Jika T ialah jenis antara muka, penegasan jenis menyemak sama ada jenis dinamik x memenuhi T. Jika semakan berjaya, nilai dinamik x tidak akan diekstrak dan nilai pulangan ialah nilai antara muka jenis T.

• Tidak kira apa jenis T, jika x ialah nilai antara muka sifar, penegasan jenis akan gagal.

Terdapat dua bentuk utama penegasan jenis dalam Go

• . Contohnya: i.(int)变量.(类型)

• . Contohnya: num,ok = i.(int). ok bermakna untuk menentukan sama ada jenis itu berjaya. 变量,bool = 变量.(类型)

Penggunaan penegasan jenis

Anda boleh melakukan perkara berikut melalui penegasan jenis

• Semak sama ada

  adalah sifari

• Semak sama ada nilai yang disimpan dalam

  adalah daripada jenis tertentu i

Spesifik Terdapat dua cara untuk digunakan:

Yang pertama:

t := i.(T)

Ungkapan ini boleh menegaskan bahawa objek antara muka (i) bukan nol, dan objek antara muka (i) Jenis nilai yang disimpan ialah T. Jika penegasan berjaya, nilai akan dikembalikan kepada t Jika penegasan gagal, panik akan dicetuskan.

Mari kita tulis sekeping kod untuk mengujinya

package main

import "fmt"

func main() {
    var i interface{} = 10
    t1 := i.(int)
    fmt.Println(t1)

    fmt.Println("=====分隔线=====")

    t2 := i.(string)
    fmt.Println(t2)
}

Output selepas dijalankan adalah seperti berikut Ia boleh didapati bahawa ia gagal semasa melaksanakan penegasan kedua dan mencetuskan panik

.

10
=====分隔线=====
panic: interface conversion: interface {} is int, not string

goroutine 1 [running]:
main.main()
        E:/GoPlayer/src/main.go:12 +0x10e
exit status 2

Jika nilai antara muka yang ingin ditegaskan adalah nil, mari lihat sama ada ia akan mencetuskan panik seperti yang dijangkakan

package main

func main() {
    var i interface{} // nil
    var _ = i.(interface{})
}

Output adalah seperti berikut, ia sememangnya akan mencetuskan panik

panic: interface conversion: interface is nil, not interface {}

goroutine 1 [running]:
main.main()
        E:/GoPlayer/src/main.go:5 +0x34
exit status 2

Jenis kedua

t, ok:= i.(T)

Sama seperti di atas, ungkapan ini juga boleh menegaskan bahawa objek antara muka (i) bukan nol, dan jenis nilai yang disimpan dalam objek antara muka (i) Ia ialah T. Jika penegasan berjaya, jenisnya akan dikembalikan kepada t, dan nilai ok adalah benar pada masa ini, menunjukkan bahawa penegasan itu berjaya.

Jika jenis nilai antara muka bukan T yang kami tegaskan, penegasan akan gagal, tetapi tidak seperti ungkapan pertama, ini tidak akan mencetuskan panik, tetapi akan menetapkan nilai ok kepada false , menunjukkan bahawa penegasan gagal, dan t ialah nilai sifar T pada masa ini.

Ubah suai sedikit contoh di atas, seperti berikut

package main

import "fmt"

func main() {
    var i interface{} = 10
    t1, ok := i.(int)
    fmt.Printf("%d-%t\n", t1, ok)

    fmt.Println("=====分隔线1=====")

    t2, ok := i.(string)
    fmt.Printf("%s-%t\n", t2, ok)

    fmt.Println("=====分隔线2=====")

    var k interface{} // nil
    t3, ok := k.(interface{})
    fmt.Println(t3, "-", ok)

    fmt.Println("=====分隔线3=====")
    k = 10
    t4, ok := k.(interface{})
    fmt.Printf("%d-%t\n", t4, ok)

    t5, ok := k.(int)
    fmt.Printf("%d-%t\n", t5, ok)
}

Output selepas dijalankan adalah seperti berikut Ia boleh didapati bahawa apabila penegasan kedua dilaksanakan, walaupun ia gagal, ia tidak mencetuskan panik.

10-true
=====分隔线1=====
-false
=====分隔线2=====
<nil> - false
=====分隔线3=====
10-true
10-true

Dalam output di atas, anda harus memberi perhatian bahawa output penegasan kedua bukanlah sama ada terdapat sebarang nilai output t2 sebelum

, tetapi kerana penegasan gagal, jadi t2 mendapat Nilai sifar rentetan juga ialah -false, iaitu panjang sifar, jadi anda tidak dapat melihat outputnya. ""

Suis Jenis

Jika anda perlu membezakan antara berbilang jenis, anda boleh menggunakan penegasan suis jenis Ini akan menjadi lebih mudah, lebih langsung dan lebih cekap daripada membuat jenis penegasan satu persatu.

package main

import "fmt"

func findType(i interface{}) {
    switch x := i.(type) {
    case int:
        fmt.Println(x, "is int")
    case string:
        fmt.Println(x, "is string")
    case nil:
        fmt.Println(x, "is nil")
    default:
        fmt.Println(x, "not type matched")
    }
}

func main() {
    findType(10)      // int
    findType("hello") // string

    var k interface{} // nil
    findType(k)

    findType(10.23) //float64
}

Outputnya adalah seperti berikut

10 is int
hello is string
<nil> is nil
10.23 not type matched

Penjelasan tambahan:

Jika nilai anda sifar, maka padanannya ialah
• case nil
Jika nilai anda tidak sepadan dengan jenis yang sepadan dalam suis-case, kemudian gunakan cawangan lalai

[Cadangan berkaitan:

Go tutorial video, Pengajaran pengaturcaraan】

Atas ialah kandungan terperinci Apakah penegasan jenis dalam bahasa go?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!