Gunakan lapan demo untuk memahami lima ciri utama penangguhan bahasa Go

Menggunakan kata kunci defer dalam bahasa Go boleh menangguhkan pelaksanaan kod sehingga tamat fungsi. Dalam pembangunan, kami sering menggunakan kata kunci defer untuk menyelesaikan kerja selepas itu, seperti menutup deskriptor fail terbuka, menutup sambungan dan mengeluarkan sumber. Kata kunci

func demo0() {
    fileName := "./test.txt"
    f, _ := os.OpenFile(fileName, os.O_RDONLY, 0)
    defer f.Close()

    contents, _ := ioutil.ReadAll(f)
    fmt.Println(string(contents))}

defer biasanya mengikuti sejurus selepas kod pembukaan sumber untuk mengelakkan terlupa melepaskan sumber Kod yang diisytiharkan secara penangguhan sebenarnya tidak akan dilaksanakan sehingga tamat fungsi. Walaupun defer adalah ringkas dan mudah digunakan, , jika anda mengabaikan ciri-cirinya, anda akan menghadapi kekeliruan semasa pembangunan . Oleh itu, saya meringkaskan lima ciri utama penangguhan dan secara beransur-ansur memperkenalkan ciri penangguhan melalui 8 demo.

Ciri 1: Pesanan panggilan apabila berbilang penangguhan digunakan: masuk dahulu, keluar terakhir

Apabila kata kunci penangguhan berbilang digunakan, pernyataan penangguhan yang diisytiharkan dahulu dipanggil kemudian. Sama seperti ciri pertama-masuk-akhir, ciri penangguhan ini juga mudah difahami Sumber yang dibuka oleh dahulu boleh dipercayai oleh kod berikutnya, jadi. selepas >.

func demo1() {
    for i := 0; i < 5; i++ {
        defer fmt.Println("defer:", i)
    }}// defer: 4// defer: 3// defer: 2// defer: 1// defer: 0

Ciri 2: Skop ialah fungsi semasa, dan terdapat tindanan penangguhan yang berbeza di bawah fungsi yang berbeza

Jalankan demo2 Ia boleh dilihat daripada hasil bahawa fungsi tanpa nama pertama dan kedua Urutan penangguhan fungsi tanpa nama dilaksanakan tidak penting.

Skop penangguhan hanyalah fungsi semasa dan dilaksanakan pada penghujung fungsi semasa, jadi terdapat tindanan penangguhan yang berbeza di bawah fungsi yang berbeza.

func demo2() {
    func() {
        defer fmt.Println(1)
        defer fmt.Println(2)
    }()

    fmt.Println("=== 新生代农民工啊 ===")

    func() {
        defer fmt.Println("a")
        defer fmt.Println("b")
    }()}// 2// 1// === 新生代农民工啊 ===// b// a

Ciri 3: Parameter fungsi selepas penangguhan disahkan pada masa pengisytiharan (parameter prakiraan)

Jalankan demo3_1, mengikut keputusan, kita boleh dapatkan : defer telah pun mengesahkan nilai parameter formal n apabila

diisytiharkan, bukan apabila dilaksanakan oleh itu, tidak kira bagaimana nombor pembolehubah berikutnya berubah, ia tidak akan menjejaskan hasil output daripada menangguhkan.

func demo3_1() {
    num := 0
    defer func(n int) {
        fmt.Println("defer:", n)
    }(num)
    // 等同 defer fmt.Println("defer:", num)

    for i := 0; i < 10; i++ {
        num++
    }

    fmt.Println(num)}//10//defer: 0

Jalankan demo3_2, mengapakah hasil keluaran akhir penangguhan sama dengan nombor pembolehubah? Kerana penunjuk digunakan di sini.

tunda
Apabila diisytiharkan , alamat yang ditunjukkan oleh penunjuk p parameter formal telah disahkan, menunjuk kepada nombor pembolehubah seterusnya nombor pembolehubah; Jadi apabila tangguh dilaksanakan , output ialah nilai semasa nombor pembolehubah yang ditunjuk oleh penunjuk p.

func demo3_2() {
    num := 0
    p := &num    defer func(p *int) {
        fmt.Println("defer:", *p)
    }(p)

    for i := 0; i < 10; i++ {
        num++
    }

    fmt.Println(*p)}//10//defer: 10

Lihat demo3_3 sekali lagi Pembolehubah yang dicetak dengan penangguhan tidak dihantar melalui parameter fungsi Angka "pembolehubah global" diperoleh hanya apabila penangguhan

dilaksanakan, jadi penangguhan. hasil keluaran Selaras dengan nombor pembolehubah.

func demo3_3() {
    num := 0
    defer func() {
        fmt.Println("defer:", num)
    }()

    for i := 0; i < 10; i++ {
        num++
    }

    fmt.Println(num)}//10//defer: 10

Ciri 4: kembali dan menangguhkan perintah pelaksanaan: pulangkan dahulu tangguh dan kemudian

Menjalankan demo4_1, anda boleh mendapati bahawa tangguh dan pulangan dilaksanakan pada penghujung fungsi, tetapi kembalikan dilaksanakan sebelum penangguhan;

func demo4_1() (int, error) {
    defer fmt.Println("defer")
    return fmt.Println("return")}// return// defer

Ini jelas daripada hasil keluaran

, tetapi apabila perintah pemulangan dan penangguhan pelaksanaan "bertemu" dengan **函数返回值**, banyak kompleks masalah akan berlaku. Dalam demo4_2, fungsi menggunakan
, dan hasil output akhir ialah 7. Ia telah melalui proses berikut: 命名返回值

1. (Pertama) nombor pembolehubah digunakan sebagai nilai pulangan, dan nilai awal ialah 0; 🎜> (Kedua) Kemudian Nombor pembolehubah diberikan nilai 10; 🎜>

2. (Kemudian) penangguhan dilaksanakan selepas pemulangan, dan nombor pembolehubah diperoleh dan diubah suai, dan nilainya ialah 7; (Akhir sekali) nombor pembolehubah digunakan sebagai nilai pulangan, dan hasil pulangan fungsi akhir ialah 7;

   Dalam demo4_3, fungsi menggunakan

   , dan output hasil akhir ialah 2. Prosesnya adalah seperti berikut:

3. memasuki fungsi, dan pembolehubah nilai pulangan tidak dibuat pada masa ini; dan menetapkan nilai kepada 10; Apabila

4. kembali, buat pembolehubah nilai pulangan dan tetapkan nilai 2 anda boleh menganggap pembolehubah nilai pulangan ini sebagai pembolehubah tanpa nama, atau sebagai pembolehubah a, b, c, d ..., tetapi ia bukan pembolehubah nombor

5. menangguhkan, tidak kira bagaimana anda mengubah suai nombor pembolehubah, ia tidak ada kaitan dengannya; nilai pulangan fungsi;

   func demo4_2() (num int) {
    num = 10
    defer func() {
        num += 5
    }()
   
    return 2}// 7

Oleh itu, hasil pengembalian fungsi terakhir ialah 2; daripada tindanan dan dilaksanakan

Jalankan demo5_1, anda boleh melihat bahawa apabila panik berlaku , akan mencetuskan penangguhan yang diisytiharkan untuk keluar daripada tindanan dan kemudian panik, dan penangguhan yang diisytiharkan selepas panik tidak akan dilaksanakan.
匿名返回值

Menggunakan ciri ini, panik boleh ditangkap melalui pemulihan dalam penangguhan untuk mengelakkan program daripada ranap.

1. Dilampirkan

Kod penuh:
2. github.com/newbugcoder/learngo/tre...

Atas ialah kandungan terperinci Gunakan lapan demo untuk memahami lima ciri utama penangguhan bahasa Go. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!