Bagaimana anda menangani kesilapan dalam perjalanan?

Bagaimana anda menangani kesilapan dalam perjalanan?

Di GO, pengendalian ralat diuruskan terutamanya menggunakan jenis error , yang merupakan antara muka yang ditakrifkan dalam pakej builtin seperti berikut:

 <code class="go">type error interface { Error() string }</code>

Mana -mana jenis yang melaksanakan antara muka ini boleh dianggap sebagai ralat. Pendekatan Go untuk pengendalian kesilapan adalah jelas dan menggalakkan pemaju untuk memeriksa dan mengendalikan kesilapan sebaik sahaja berlaku. Corak umum untuk mengendalikan kesilapan dalam GO adalah untuk memeriksa nilai pulangan ralat selepas panggilan fungsi dan memutuskan apa yang perlu dilakukan berdasarkan sama ada ralat telah berlaku. Inilah contoh mudah:

 <code class="go">result, err := someFunction() if err != nil { // Handle the error fmt.Println("An error occurred:", err) return } // Use result safely</code>

Di Go, fungsi boleh mengembalikan pelbagai nilai, dan ia adalah konvensyen untuk mengembalikan ralat sebagai nilai terakhir. Apabila menulis fungsi, anda harus sentiasa mempertimbangkan apa yang mungkin berlaku dan mengembalikannya dengan sewajarnya. Contohnya:

 <code class="go">func divide(a, b int) (int, error) { if b == 0 { return 0, errors.New("division by zero") } return a / b, nil }</code>

Apabila memanggil divide , anda akan mengendalikan ralat seperti ini:

 <code class="go">quotient, err := divide(10, 2) if err != nil { log.Fatal(err) } fmt.Println(quotient) // Output: 5</code>

Apakah amalan terbaik untuk pengendalian kesilapan di GO?

Pengendalian ralat yang berkesan di GO melibatkan beberapa amalan terbaik untuk memastikan kod anda teguh dan dapat dipelihara:

1. Sentiasa periksa kesilapan: Jangan sekali -kali mengabaikan kesilapan. Sentiasa periksa mereka dan mengendalikannya dengan sewajarnya, walaupun ia hanya melog masuk kesilapan dan pelaksanaan berterusan.
2. Jadilah khusus: apabila membuat kesilapan, menjadi seperti yang mungkin. Ini menjadikannya lebih mudah untuk debug dan mengendalikan jenis kesilapan tertentu.

3. Gunakan pembungkus: GO 1.13 Pembungkus ralat yang diperkenalkan, yang membolehkan anda menambah konteks kepada ralat tanpa kehilangan ralat asal. Gunakan fmt.Errorf dengan kata kerja %w untuk membungkus ralat.

    <code class="go">err := fmt.Errorf("failed to read file: %w", os.ErrNotExist)</code>

4. Buat jenis ralat tersuai: Apabila perlu, tentukan jenis ralat tersuai untuk senario yang lebih kompleks. Ini dapat membantu membezakan antara pelbagai jenis kesilapan dan mengendalikannya secara berbeza.

5. Gunakan fungsi tertunda: Gunakan fungsi tertunda untuk mengendalikan sumber dan pembersihan, yang juga boleh digunakan untuk pengendalian ralat, terutamanya dengan recover .

    <code class="go">defer func() { if r := recover(); r != nil { fmt.Println("Recovered from panic:", r) } }()</code>

6. Pembalakan: Gunakan pembalakan berstruktur untuk log ralat dengan konteks tambahan. Ini membantu dalam debugging dan pemantauan.
7. Strategi pengendalian ralat: Tentukan strategi pengendalian ralat awal projek anda. Adakah anda akan mencuba operasi, gagal dengan cepat, atau log dan teruskan? Konsistensi dalam pengendalian kesilapan di seluruh codebase adalah penting.
8. Dokumentasi: Dokumen bagaimana kesilapan dikendalikan dalam API anda dan apa kesilapan yang boleh dikembalikan oleh fungsi anda. Ini menjadikan kod anda lebih mudah difahami dan dapat dipelihara.

Bagaimana anda boleh membuat jenis ralat tersuai dalam GO?

Mewujudkan jenis ralat tersuai di GO boleh berguna untuk pengendalian ralat yang lebih terperinci dan membezakan antara pelbagai jenis kesilapan. Berikut adalah cara anda boleh menentukan jenis ralat tersuai:

1. Tentukan jenis ralat: Anda boleh menentukan jenis ralat tersuai dengan membuat struktur yang melaksanakan antara muka error .

    <code class="go">type MyError struct { Code int Message string } func (e *MyError) Error() string { return fmt.Sprintf("Error %d: %s", e.Code, e.Message) }</code>

2. Gunakan ralat tersuai: Setelah ditakrifkan, anda boleh menggunakan jenis ralat tersuai anda dalam fungsi anda.

    <code class="go">func doSomething() error { // Some operation fails return &MyError{Code: 404, Message: "Resource not found"} }</code>

3. Semak jenis ralat tersuai: Anda boleh menyemak jenis ralat tersuai menggunakan penegasan jenis.

    <code class="go">err := doSomething() if err != nil { if e, ok := err.(*MyError); ok { fmt.Printf("Custom error: Code %d, Message %s\n", e.Code, e.Message) } else { fmt.Println("Unknown error:", err) } }</code>

4. Bungkus ralat: Anda juga boleh membungkus ralat tersuai anda dengan konteks tambahan menggunakan fmt.Errorf dan %w .

    <code class="go">err := doSomething() if err != nil { return fmt.Errorf("operation failed: %w", err) }</code>

Alat atau perpustakaan apa yang boleh membantu pengendalian ralat di GO?

Beberapa alat dan perpustakaan dapat membantu meningkatkan pengendalian ralat di GO:

1. PKG/Ralat: Pakej github.com/pkg/errors menyediakan ciri pengendalian ralat tambahan, seperti jejak stack, yang boleh sangat berguna untuk debugging. Ia juga menyokong pembungkus ralat, yang kemudiannya dimasukkan ke dalam perpustakaan standard.

    <code class="go">err := errors.New("original error") wrappedErr := errors.Wrap(err, "additional context")</code>

2. Uber-Go/Zap: Perpustakaan pembalakan ini menyediakan pembalakan berstruktur, cepat, dan bertingkat. Ia amat berguna untuk kesilapan pembalakan dengan konteks tambahan.

    <code class="go">logger := zap.NewExample() defer logger.Sync() sugar := logger.Sugar() sugar.Infow("Failed to fetch URL.", "url", url, "attempt", 3, "backoff", time.Second, )</code>

3. Go-Chi/Chi: Jika anda membina perkhidmatan web, router github.com/go-chi/chi mempunyai middleware terbina dalam untuk mengendalikan dan menunggang kesilapan dengan cara yang standard.

    <code class="go">r := chi.NewRouter() r.Use(middleware.Recoverer) r.Get("/", func(w http.ResponseWriter, r *http.Request) { w.Write([]byte("hello world")) })</code>

4. ERRGROUP: Dari pakej golang.org/x/sync/errgroup , errgroup.Group membantu menguruskan goroutine dan kesilapan mereka secara berpusat.

    <code class="go">g := new(errgroup.Group) g.Go(func() error { // do something return nil }) if err := g.Wait(); err != nil { log.Fatal(err) }</code>

5. github.com/hashicorp/go-multierror: Pakej ini membolehkan anda menggabungkan pelbagai ralat ke dalam satu ralat, yang boleh berguna apabila mengendalikan pelbagai operasi yang mungkin gagal.

    <code class="go">var errs error errs = multierror.Append(errs, errors.New("first error")) errs = multierror.Append(errs, errors.New("second error")) if errs != nil { log.Fatal(errs) }</code>

Menggunakan alat dan perpustakaan ini dapat meningkatkan strategi pengendalian ralat anda secara signifikan, menjadikan aplikasi anda lebih mantap dan lebih mudah untuk debug dan mengekalkan.

Atas ialah kandungan terperinci Bagaimana anda menangani kesilapan dalam perjalanan?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!