golang mendapat ralat program

Dalam pembangunan program, pengendalian ralat adalah tugas yang sangat penting. Apabila program menghadapi ralat, ia perlu ditemui dan dikendalikan dalam masa, jika tidak, keseluruhan program akan ranap. Di Golang, mekanisme pengendalian ralat terbina dalam boleh membantu kami mengendalikan ralat program dengan lebih baik. Artikel ini menerangkan cara mendapatkan ralat program di Golang.

Pengendalian ralat

Di Golang, ralat dianggap sebagai jenis, jenis error. Biasanya, apabila fungsi mengembalikan nilai jenis error, ini bermakna fungsi itu mungkin mengembalikan ralat.

Berikut ialah fungsi yang mengembalikan panjang rentetan StringLength Apabila rentetan masuk kosong, ralat akan dikembalikan:

func StringLength(str string) (int, error) {
    if str == "" {
        return 0, errors.New("String is empty")
    }
    return len(str), nil
}

Dalam kod di atas, errors.New. Kaedah digunakan untuk mencipta objek jenis error.

Apabila kita memanggil StringLength, kita perlu menyemak sama ada objek ralat yang dikembalikan kosong untuk menentukan sama ada fungsi itu berjaya dilaksanakan:

str := "hello world"
length, err := StringLength(str)
if err != nil {
    fmt.Println("Error:", err)
    return
}
fmt.Printf("The length of "%s" is %d
", str, length)

Output:

The length of "hello world" is 11

Apabila diluluskan dalam Apabila rentetan kosong, outputnya ialah:

Error: String is empty

Melalui contoh di atas, kita dapat melihat bahawa mekanisme pengendalian ralat Golang adalah sangat intuitif dan mudah.

Butiran mesej ralat

Kadangkala kita perlu mendapatkan maklumat yang lebih terperinci tentang ralat, seperti lokasi ralat pelaksanaan, kod ralat, dsb. Di Golang, anda boleh membungkus ralat asal dan maklumat ralat baharu bersama-sama melalui fungsi errors pakej Wrap dan mengembalikan nilai ralat baharu. Nilai ralat baharu ini membawa maklumat ralat asal dan ralat tersuai untuk memberikan lebih banyak butiran ralat.

Berikut ialah contoh:

func Divide(x, y float64) (float64, error) {
    if y == 0 {
        return 0, errors.New("division by zero")
    }
    return x / y, nil
}

func main() {
    x, y, err := 4.0, 0.0, error(nil)
    
    // 错误发生在这里
    result, err := Divide(x, y)
    if err != nil {
        err = errors.Wrap(err, "can't perform division")
    }
    fmt.Printf("Result: %v, error: %v", result, err)
}

Apabila menggunakan kaedah Wrap untuk membungkus ralat, ia menambah awalan dan mengembalikan objek ralat baharu yang mengandungi ralat asal dan maklumat ralat baharu . Dalam contoh ini, kami menggunakan kaedah Wrap dan awalan mesej ralat baharu dengan "tidak boleh melakukan pembahagian".

Output mesej ralat pada masa ini adalah seperti berikut:

Result: 0, error: can't perform division: division by zero

Seperti yang anda lihat, mesej ralat mengandungi mesej ralat tersuai dan mesej ralat asal.

panik

Apabila Goroutine menghadapi ralat atau pengecualian yang tidak boleh dipulihkan, anda boleh menggunakan fungsi panic untuk menghantar mesej ralat ke atas dan menamatkan pelaksanaan program. Mana-mana fungsi peringkat atas mempunyai peluang untuk mengendalikan ralat ini atau menghantarnya kepada fungsi peringkat lebih tinggi sehingga program berhenti berjalan.

Berikut ialah contoh:

func processFile(filename string) error {
    file, err := os.Open(filename)
    if err != nil {
        return errors.Wrap(err, "can't open file")
    }
    defer file.Close()

    // ... process file

    if err != nil {
        panic(errors.Wrap(err, "can't process file"))
    }

    return nil
}

Dalam kod di atas, apabila pemprosesan fail gagal, kami menggunakan fungsi panic untuk melaporkan ralat dan berharap Goroutines atau program lain dapat menanganinya. Anda boleh menggunakan fungsi processFile untuk menangkap recover dan melakukan pengendalian ralat dalam kod yang memanggil panic.

func main() {
    defer func() {
        if p := recover(); p != nil {
            fmt.Printf("Recovered from panic: %v
", p)
        }
    }()

    err := processFile("test.txt")
    if err != nil {
        fmt.Println(err)
    }
}

Atur cara di atas boleh berjalan seperti biasa, tetapi apabila ralat berlaku, maklumat panik akan dicetak dan ditangkap dengan fungsi recover.

Ringkasan

Di Golang, pengendalian ralat adalah tugas yang sangat penting. Anda boleh menentukan sama ada fungsi tersebut berjaya dilaksanakan dengan mengembalikan nilai jenis error dan menyemak sama ada ia kosong. Apabila anda perlu mendapatkan lebih banyak butiran ralat, anda boleh menggunakan fungsi Wrap untuk pembungkusan. Apabila Goroutine menghadapi ralat atau pengecualian yang tidak boleh dipulihkan, anda boleh menggunakan fungsi panic untuk menghantar maklumat ralat ke atas dan menamatkan pelaksanaan program.

Tidak kira dalam apa jua keadaan, adalah sangat penting untuk mengesan dan menangani ralat dalam masa. Hanya dengan cara ini kebolehpercayaan dan kestabilan program dapat dijamin.

Atas ialah kandungan terperinci golang mendapat ralat program. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!