Mengapa dakwaan Golang gagal? Bagaimana untuk mengelakkannya?

Golang ialah bahasa pengaturcaraan yang sedang berkembang pesat. Walau bagaimanapun, walaupun dengan bahasa yang cekap sedemikian, beberapa masalah yang tidak dijangka pasti akan timbul. Di Golang, salah satu masalah biasa ialah kegagalan penegasan (Assertion Failed).

Kegagalan penegasan bermakna semasa program berjalan, syarat tertentu tidak dipenuhi, menyebabkan program ranap. Sebagai contoh, jika anda menggunakan penegasan untuk menentukan panjang kepingan tertentu, atur cara akan gagal untuk menegaskan apabila panjang kepingan itu kurang daripada had yang diketahui. Pada masa ini, atur cara akan membuang mesej ralat panik, menyebabkan atur cara tidak dapat meneruskan pelaksanaan.

Walaupun masalah ini nampaknya tidak mudah berlaku, sebenarnya ia boleh merosakkan program anda. Oleh itu, kita perlu memahami mengapa dakwaan gagal dan bagaimana untuk mengelakkannya.

Punca kegagalan penegasan

1. Pembolehubah tidak dimulakan

Di Golang, jika pembolehubah tidak dimulakan secara eksplisit, nilainya Lalai kepada nilai sifar untuk jenis ini . Untuk sesetengah nilai (seperti jenis integer), nilai sifar ialah 0, dan untuk nilai lain, ia adalah sifar atau kepingan kosong.

Oleh itu, jika anda mengendalikan pembolehubah yang tidak dimulakan, seperti kepingan atau tatasusunan, ia akan menyebabkan penegasan gagal. Oleh kerana nilai lalai pembolehubah ini ialah nilai sifar, tidak ada cara untuk mendapatkan panjang atau indeksnya. Dalam kes ini, untuk mengelakkan kegagalan penegasan, anda perlu memastikan bahawa anda memulakan atau menetapkan struktur data atau elemen tatasusunan panjang boleh ubah sebelum membacanya.

2. Julat tatasusunan atau kepingan di luar sempadan

Di Golang, akses kepada tatasusunan dan kepingan adalah berdasarkan subskrip. Ini bermakna jika anda mengakses tatasusunan atau kepingan menggunakan subskrip yang tidak sah, penegasan akan gagal. Keadaan ini sangat biasa dan sangat terdedah kepada ralat apabila menggunakan berbilang pembolehubah indeks dalam gelung.

Untuk mengelakkan kegagalan penegasan, anda perlu menyemak sama ada pembolehubah berada di luar sempadan sebelum mengakses tatasusunan atau kepingan. Anda boleh menggunakan operator perbandingan untuk menyemak sama ada ia lebih besar daripada atau sama dengan panjang atau kurang daripada 0.

Sebagai contoh, coretan kod berikut menunjukkan cara untuk lelaran dengan selamat pada kepingan:

slice := []int{1, 2, 3, 4, 5}
for i := 0; i < len(slice); i++ {
    if i >= len(slice) || i < 0 {
        // 索引越界
        break
    }
    // 访问数据
    fmt.Println(slice[i])
}

3. Jenis penegasan gagal

Di Golang, kami selalunya Jenis antara muka perlu ditukar kepada jenis sebenar. Biasanya, kami menggunakan penegasan jenis untuk melakukan penukaran jenis ini. Walau bagaimanapun, jika penghakiman jenis gagal, ia akan menyebabkan penegasan gagal.

Kegagalan penghakiman jenis mungkin berlaku atas pelbagai sebab. Contohnya, jika anda cuba menukar penuding kepada int kepada rentetan, penegasan itu gagal. Sebagai alternatif, jika anda cuba menukar jenis antara muka kepada jenis yang tidak boleh ditukar, penegasan akan gagal.

Untuk mengelakkan perkara ini, anda perlu memastikan anda melakukan penentuan jenis yang betul dan sentiasa menggunakan refleksi untuk menyemak sama ada jenis antara muka sepadan dengan jenis sasaran.

Bagaimana untuk mengelakkan kegagalan penegasan

1. Pastikan nilai pembolehubah yang sah melalui permulaan dan penetapan

Di Golang, pembolehubah yang tidak diinisialisasi biasanya mempunyai nilai lalai. nilai adalah nol. Oleh itu, untuk mengelakkan kegagalan penegasan, anda perlu memulakan atau menetapkan nilai yang sah kepada pembolehubah sebelum menggunakannya.

Sebagai contoh, berikut ialah pengisytiharan dan pemulaan kepingan:

// 声明切片
var slice []int

// 初始化切片
slice = make([]int, 0)

Sebagai alternatif, anda boleh mengisytiharkan dan memulakan pembolehubah menggunakan perisytiharan pembolehubah pendek:

slice := make([]int, 0)

2. Semakan had pada indeks

Untuk mengelakkan julat tatasusunan atau hirisan keluar dari sempadan, anda perlu melakukan semakan had pada indeks. Anda boleh menggunakan operator perbandingan untuk menyemak sama ada indeks lebih besar daripada atau sama dengan sifar dan kurang daripada panjang tatasusunan atau kepingan.

Contohnya, berikut ialah traversal hirisan yang selamat:

// 安全获取数组元素的值
func safeGet(slice []int, index int) int {
    if index >= len(slice) || index < 0 {
        return -1
    }
    return slice[index]
}

func main() {
    slice := []int{1, 2, 3, 4, 5}

    // 遍历切片元素
    for i := 0; i < len(slice); i++ {
        fmt.Println(safeGet(slice, i))
    }
}

3. Sebelum menggunakan penegasan jenis, semak sama ada jenis sepadan

Akhir sekali, apabila anda Apabila menggunakan penegasan jenis, pastikan anda menyemak sama ada jenis antara muka sepadan dengan jenis sasaran sebelum membuat penegasan. Jika tidak, anda mungkin menghadapi kegagalan penegasan.

Untuk mengelakkan situasi ini, anda boleh menggunakan mekanisme pantulan untuk mengesan jenis. Sebagai contoh, coretan kod berikut menunjukkan cara menggunakan pantulan untuk menyemak sama ada nilai daripada rentetan jenis:

// 判断一个值是否是字符串类型
func isString(val interface{}) bool {
    tt := reflect.TypeOf(val)
    if tt.Kind() == reflect.String {
        return true
    }
    return false
}

func main() {
    fmt.Println(isString("Hello, world!"))  // 输出 true 
    fmt.Println(isString(123))  // 输出 false 
}

Kesimpulan

Kegagalan penegasan Golang adalah masalah biasa, tetapi ia juga masalah mudah terabai. Untuk mengelakkan ini, anda perlu memulakan dan menetapkan pembolehubah, melakukan semakan sempadan pada tatasusunan atau kepingan dan pastikan jenis pembolehubah sepadan sebelum membuat penegasan jenis. Hanya dengan cara ini anda boleh memastikan bahawa program anda tidak ranap akibat kegagalan penegasan.

Atas ialah kandungan terperinci Mengapa dakwaan Golang gagal? Bagaimana untuk mengelakkannya?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!