Apakah hubungan antara tangguh dan panik dalam bahasa Go?

Bahasa Go ialah bahasa pengaturcaraan baharu yang telah menambahkan beberapa sintaks dan ciri unik, antaranya tangguh dan panik ialah dua ciri yang sangat penting. Artikel ini akan memperkenalkan hubungan antara tangguh dan panik dalam bahasa Go serta penggunaan dan cirinya.

Penggunaan penangguhan

Pernyataan penangguhan dalam bahasa Go digunakan untuk mendaftarkan fungsi Apabila pelaksanaan fungsi ini tamat atau skop semasa tamat, fungsi yang didaftarkan akan dilaksanakan secara automatik. tangguh boleh digunakan dalam berbilang senario seperti pelepasan sumber, buka kunci dan pengendalian ralat.

Berikut ialah contoh sumber pelepasan tangguh:

func main() {
    file, err := os.Open("myfile.txt")
  // 在函数结束时，会自动关闭文件
    defer file.Close()
  
    if err != nil {
        fmt.Println("Failed to open file.")
        return
    }
    // ...
}

didaftarkan melalui fungsi Tutup() bagi fail tangguh, dan fail akan ditutup secara automatik apabila pelaksanaan fungsi tamat.

Berikut ialah contoh membuka kunci kunci tangguh:

func main() {
    var lock sync.Mutex
    lock.Lock()
  // 当函数执行结束时，会自动解锁
    defer lock.Unlock()
  
    // ...
}

Fungsi Unlock() akan dipanggil secara automatik untuk membuka kunci apabila pelaksanaan fungsi tamat.

Arahan pelaksanaan penangguhan adalah dari belakang ke hadapan, yang bermaksud bahawa jika beberapa penyata penangguhan didaftarkan, ia akan dilaksanakan dalam susunan terbalik. Contoh berikut akan mengeluarkan Defer 2, kemudian Defer 1.

func main() {
    defer fmt.Println("Defer 1")
    defer fmt.Println("Defer 2")
    fmt.Println("Hello")
}

Penggunaan panik

Kata kunci panik dalam bahasa Go digunakan untuk membuang pengecualian dan menamatkan pelaksanaan fungsi atau program semasa. Panik akan menyebarkan timbunan panggilan fungsi sehingga ia ditangkap oleh fungsi recover(). Jika tidak ditangkap, keseluruhan program akan keluar dan timbunan panggilan dicetak.

Dalam kod contoh berikut, apabila panjang rentetan input kurang daripada 5, panik akan dicetuskan dan pelaksanaan program akan ditamatkan. Output

func hello(name string) {
    if len(name) < 5 {
        panic("Name is too short.")
    }
    fmt.Println("Hello", name)
}

func main() {
    hello("Tom")
    hello("Bob")
    hello("me")
}

adalah seperti berikut:

Hello Tom
Hello Bob
panic: Name is too short.

goroutine 1 [running]:
main.hello(...)
    /Users/user/goland/src/main.go:4
main.main()
    /Users/user/goland/src/main.go:10 +0x81
exit status 2

Di sini kita dapat melihat bahawa apabila nama input ialah me, panik akan dicetuskan dan pelaksanaan program akan ditamatkan.

Hubungan antara penangguhan dan panik

panik memainkan peranan untuk menamatkan pelaksanaan program dengan serta-merta, yang bermaksud ia boleh dicetuskan pada bila-bila masa, termasuk sebelum tamat pelaksanaan fungsi. Untuk memastikan program boleh mengeluarkan sumber dalam masa dan melaksanakan beberapa kerja pembersihan yang diperlukan, bahasa Go memperkenalkan mekanisme penangguhan, yang membolehkan fungsi melakukan beberapa operasi pembersihan sebelum keluar.

Apabila panik dicetuskan dalam fungsi, ia akan keluar serta-merta dan melaksanakan semua fungsi tangguh yang didaftarkan sebelum fungsi semasa. Kod contoh berikut secara manual mencetuskan panik dan melaksanakan fungsi tangguh dua kali sebelum keluar.

func main() {
    defer fmt.Println("Defer 1")
    defer fmt.Println("Defer 2")
    
    panic("Oops! Something went wrong.")
}

Output adalah seperti berikut:

Defer 2
Defer 1
panic: Oops! Something went wrong.

goroutine 1 [running]:
main.main()
    /Users/user/goland/src/main.go:7 +0x81
exit status 2

Kita dapat melihat bahawa selepas mencetuskan panik, kedua-dua fungsi penangguhan dilaksanakan dalam susunan terbalik.

Selain mendaftarkan fungsi penangguhan pada penghujung fungsi, bahasa Go juga membenarkan berbilang fungsi penangguhan didaftarkan dalam fungsi tersebut. Ini bermakna jika terdapat berbilang fungsi penangguhan dalam fungsi, walaupun salah satu penangguhan mencetuskan panik, fungsi penangguhan yang lain masih boleh dilaksanakan.

Kod contoh berikut menunjukkan bahawa apabila fungsi mendaftarkan beberapa pernyataan penangguhan, salah satu fungsi penangguhan mencetuskan panik, tetapi fungsi penangguhan yang lain masih dilaksanakan.

func init() {
    fmt.Println("Init 1")
}

func init() {
    fmt.Println("Init 2")
}

func main() {
    defer fmt.Println("Defer 1")
    
    defer func() {
        if err := recover(); err != nil {
            fmt.Println("Recovered:", err)
        }
    }()
    
    defer fmt.Println("Defer 2")
    
    panic("Oops! Something went wrong.")
}

Hasil keluaran adalah seperti berikut:

Init 1
Init 2
Defer 2
Recovered: Oops! Something went wrong.
Defer 1

Kita dapat melihat bahawa fungsi itu mula-mula melaksanakan dua fungsi init, dan kemudian melaksanakan tiga fungsi tangguh dalam urutan. Apabila salah satu penangguhan mencetuskan panik, tetapi ditangkap oleh penangguhan yang lain dan program disambung semula, akhirnya kedua-dua fungsi penangguhan dilaksanakan secara normal.

Dalam pembangunan sebenar, penangguhan dan panik sering digunakan secara berpasangan, penangguhan digunakan untuk melepaskan sumber dan melakukan operasi pembersihan, dan panik digunakan untuk mengendalikan pengecualian. Apabila fungsi perlu melakukan beberapa operasi pembersihan sebelum keluar, kita boleh menggunakan fungsi pembungkus tangguh pada permulaan fungsi dan menggunakan fungsi recover() untuk menghalang fungsi daripada keluar awal. Cara penulisan ini sangat biasa dan memberikan jaminan yang kukuh untuk kami menulis program yang mantap.

Atas ialah kandungan terperinci Apakah hubungan antara tangguh dan panik dalam bahasa Go?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!