Berhenti awal untuk menang!

Ringkasan yang sangat singkat: Keluar dari program anda apabila anda mendapat ralat boleh menjadi idea yang baik. Menggunakan gobail akan menjadikan hidup anda lebih mudah.

Apabila anda mendapat ralat dalam kod Go anda, anda biasanya akan melihat sesuatu seperti ini:

err := myFunc()
if err != nil {
    return fmt.Errorf("doing my thing: %w", err)
}

Anda akan melihat beberapa perkara dalam contoh ini:

1. Anda perlu menyemak sama ada terdapat ralat
2. Terdapat beberapa teks yang akan membantu mendiagnosis ralat
3. Dan ralat itu dibalut, dihantar kembali dengan teks

Jadi apa yang berlaku seterusnya? Baik semuanya berlaku lagi. Anda menyemak nilai ralat, menerangkannya, menghantarnya kembali. Dan kemudian semuanya bermula semula.

Mengapa kita melakukan ini? Kenapa semua usaha ini?

Semuanya bergantung pada perisian yang anda tulis. Apabila anda mendapat ralat, anda perlu membuat keputusan. Apakah yang berlaku kepada ralat itu?

Jika anda menulis API HTTP membalas permintaan maka akhirnya anda akan sampai ke beberapa jenis pengendali HTTP dan anda akan menukar ralat itu kepada beberapa respons - mungkin sedikit 400 dengan format peringatan yang sopan mereka meminta dengan betul atau mungkin mesej 500 dan membimbangkan tentang kesihatan permohonan anda. Sebagai alternatif, jika anda menulis beberapa jenis alat CLI maka anda mungkin memutuskan bahawa ralat itu akhirnya akan diteruskan kembali ke fungsi utama anda. Untuk apa-apa jenis program, anda mungkin memutuskan bahawa sudah cukup - program itu sepatutnya tamat sahaja kerana anda tidak boleh melakukan apa-apa lagi.

Mari kita lihat pilihan terakhir ini. Bilakah sesuai untuk keluar dari program anda? Berikut ialah beberapa sebab yang boleh saya fikirkan:

a. Tiada apa-apa lagi yang perlu dilakukan, kesilapan itu sangat teruk sehingga semuanya harus dihentikan sekarang
b. Tiada akibat untuk menamatkan program (tiada pembersihan diperlukan, tiada status untuk bertindak balas)
c. Berhenti awal adalah wajar, mungkin anda mempunyai monitor yang memulakan semula proses dengan bersih

Walau apa pun alasannya, anda perlu mempertimbangkan cara anda akan keluar dengan bersih. Sekarang perkara pertama yang anda mungkin cuba ialah ini:

err := myFunc()
if err != nil {
    fmt.Printf("doing my thing: %v", err)
    os.Exit(1)
}

Ia kelihatan agak serupa dengan kod pengendalian ralat asal kami tetapi dengan beberapa perbezaan penting. Yang pertama agak jelas - terdapat kenyataan berhenti-kanan-g*****n-sekarang yang hebat di sana. Program anda tidak akan diteruskan. Perkara kedua mungkin lebih penting. Kod yang memanggil sampel ini tidak perlu bimbang tentang mengendalikan sebarang ralat. Tiada laluan kod tambahan yang perlu diuji - kami boleh mempercayai bahawa kod panggilan tidak mempunyai blok if untuk diuji kerana tiada apa yang dikembalikan yang perlu kami periksa.

Menguji jalan keluar anda

Jadi, saya mungkin agak bersemangat apabila saya mencadangkan anda hanya perlu mempercayai bahawa kod keluar anda hanya akan berfungsi. Anda mungkin perlu menyemak sama ada sebab program baharu anda telah berhenti adalah atas sebab yang betul.

Percubaan 1 - jalankan sahaja program anda

Ini rasanya ia sepatutnya mudah. Berikut ialah beberapa perkara yang perlu dipertimbangkan - dalam kes yang paling mudah, anda hanya akan menjalankan program anda dan mencetuskan keadaan ralat. Sebagai contoh, dapatkan alat CLI anda untuk membuka fail yang tidak wujud. Anda boleh melakukan ini secara manual untuk beberapa kes mudah. Apabila bilangan ujian meningkat, anda mungkin memerlukan beberapa jenis automasi di sekelilingnya untuk membantu anda.

Nota sampingan ringkas - ini mungkin subjek catatan blog lain tetapi cara kegemaran saya semasa menguji alatan CLI menggunakan godog untuk menulis ujian. Ia boleh menjadi sedikit rumit tetapi saya dapati ia sangat berkuasa. Berikut ialah beberapa contoh yang baik tentang cara saya mendekatinya dengan layli dan tunggu.

Pendekatan ini akan membawa anda jauh tetapi kadangkala sukar untuk mencipta keadaan yang akan menggunakan semua laluan kod yang anda ingin yakini dengan betul.

Percubaan 2 - mengejek pintu keluar

OK jadi sekarang kita akan menggunakan beberapa ciri bahasa Go. Kita sebenarnya tidak perlu memanggil os.Exit - kita boleh memanggil sesuatu yang kelihatan seperti itu. Jadi lihat ini:

err := myFunc()
if err != nil {
    return fmt.Errorf("doing my thing: %w", err)
}

Jadi bagaimana kita akan memanfaatkan ini untuk ujian kita? Oleh kerana fungsi kini telah bertukar menjadi pembolehubah (customExit) maka kita boleh menggantikan nilai dengan sesuatu yang lain yang kita mahu lakukan. Macam ni...

err := myFunc()
if err != nil {
    fmt.Printf("doing my thing: %v", err)
    os.Exit(1)
}

Ini adalah pendekatan yang lebih mesra ujian unit. Anda boleh menyemak sama ada kod keluar yang digunakan adalah betul - dan anda benar-benar memanggil fungsi keluar.

Di permukaan, ini kelihatan hebat tetapi terdapat satu masalah besar - jika ujian anda lulus, maka anda memprogramkan akan meneruskan dan melaksanakan fungsi yang lain apabila anda menjangkakan ia akan keluar. Ia akan diteruskan walaupun persediaan ujian bermakna bahawa pelaksanaan yang lain tidak sah dan menyebabkan masalah untuk ujian anda, seperti menyebabkan panik.

Mengalih keluar kod untuk mengalih keluar ujian

Nah, ini kedengaran agak melampau!

Saya rasa saya patut menjelaskan... Biasanya dalam syarikat yang "diurus dengan baik" anda perlu memastikan bahawa setiap baris kod telah terbukti berfungsi sebelum ini jika boleh diletakkan di hadapan pelanggan anda. Menggunakan teknik di atas, anda mungkin tidak dapat menjana metrik liputan yang betul untuk membuktikan bahawa anda bagus. Walaupun ianya remeh untuk difikirkan.
Semua contoh di atas telah mengandaikan bahawa apabila kita mendapat ralat maka kita perlu menyemaknya untuk memutuskan apa yang perlu dilakukan (Keluar dengan membalas dendam). Bukankah bagus jika kita dapat keluar tanpa perlu menyemak sama ada terdapat ralat?

Mari kita lihat apa yang boleh kita lakukan.

err := myFunc()
if err != nil {
    return fmt.Errorf("doing my thing: %w", err)
}

Lihat contoh di atas. Fungsinya adalah sama tetapi pelaksanaan myFunc jauh lebih mudah sekarang - tiada syarat. Kami boleh menyemak pelaksanaan fungsi checkExit dalam ujiannya sendiri, bermakna apa sahaja yang baharu dalam myFunc() boleh disahkan dengan lebih mudah.

Memperkenalkan gobail

Libraray baharu, gobail telah dicipta yang membolehkan anda yakin bahawa jika terdapat ralat maka ia akan dikendalikan tanpa perlu menambah kerumitan pada kod anda sendiri. Ia kelihatan seperti ini:

err := myFunc()
if err != nil {
    fmt.Printf("doing my thing: %v", err)
    os.Exit(1)
}

Pustaka ini telah diuji sepenuhnya, dengan metrik liputan, untuk membuktikannya. Anda boleh menggunakannya dengan selamat tanpa perlu risau bahawa ralat akan dilangkau. Ia juga akan mengendalikan fungsi dengan 2 nilai pulangan, seperti:

type ExitFunc func(code int)

var customExit ExitFunc = os.Exit

func myFunc() {
    err := someOtherFunc()
    if err != nil {
        fmt.Printf("doing my thing: %v", err)
        customExit(1)
    }
}

Perhatikan juga bahawa anda memasukkan ralat yang menyebabkan semua masalah anda.

Anda juga boleh panik dan bukannya keluar, mencetak jejak tindanan kami dan maklumat kontekstual lain daripada program apabila panik ditimbulkan. Lihat dokumen untuk mendapatkan butiran lanjut.

Mengasingkan kebergantungan

Semasa anda menulis perisian dengan gobail, anda akan mendapati kebanyakannya anda perlu menggunakannya apabila bercakap dengan perpustakaan luaran. Ini mempunyai kod tambahan yang biasanya anda perlu tulis untuk mengendalikan semua kes ralat boleh dibungkus dalam panggilan ke Return atau Return2 dan menganggap bahawa kami akan keluar apabila perlu.

Kesimpulan

Kadang-kadang adalah wajar untuk keluar dari program anda dan bukannya mengendalikan ralat anda secara terperinci. Perpustakaan gobail telah dibuat dan disahkan supaya anda tidak perlu risau tentang butiran membuktikan perkara ini.

Jika anda mendapati peningkatan yang boleh dibuat atau hanya mempunyai cadangan, maka bangkitkan PR atau isu mengenai repo dan pembangun akan menyelesaikannya apabila mereka boleh!

Atas ialah kandungan terperinci Berhenti awal untuk menang!. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!