Go là một ngôn ngữ lập trình phổ biến đã trở nên phổ biến vì tính hiệu quả, tốc độ và hiệu quả của nó. Tuy nhiên, lỗi có thể xảy ra trong giai đoạn phát triển và thực thi, giống như bất kỳ ngôn ngữ lập trình nào khác. Xử lý lỗi một cách hiệu quả là điều cần thiết để đảm bảo độ tin cậy và ổn định của các chương trình Go của bạn.
Bài viết này sẽ xem xét một số phương pháp và quy trình được đề xuất để quản lý lỗi trong Go.
Xử lý lỗi trong Golang
Trong Go, bạn có thể xử lý lỗi thông qua các phương pháp được đề cập dưới đây:
1: Hàm mới ()
Ngôn ngữ Go cung cấp Mới() chức năng quản lý lỗi. Chức năng này, có sẵn trong gói lỗi tích hợp sẵn, cho phép nhà phát triển tạo thông báo lỗi tùy chỉnh cho chương trình của họ. Bằng cách sử dụng Mới() chức năng, các nhà phát triển có thể xử lý lỗi một cách hiệu quả và cung cấp các thông báo lỗi có ý nghĩa cho người dùng.
gói chính
nhập khẩu 'lỗi'
nhập khẩu 'fmt'
kiểm tra chức năng ( chuỗi tên ) lỗi {
nError := error.Mới ( 'Tên không hợp lệ' )
nếu như tên ! = 'Linux' {
trở lại nLỗi
}
trở lại không
}
chức năng chính ( ) {
tên := 'Linux'
sai := kiểm tra ( tên )
nếu như sai lầm ! = không {
fmt.Println ( sai lầm )
} khác {
fmt.Println ( 'Tên hợp lệ' )
}
}
Đoạn mã trên sử dụng Mới() tên kiểm tra chức năng để xem nếu chuỗi Linux phù hợp với tên được đặt. Hàm tạo ra lỗi với thông báo Tên không hợp lệ nếu tên không phải là Linux . Hàm trả về nil để cho biết rằng không có lỗi nếu tên bằng Linux .
Biến tên được đặt thành Linux trong lệnh gọi của chức năng chính đến tên kiểm tra hàm, cũng lấy biến tên làm đối số. Chức năng chính in thông báo lỗi nếu tên kiểm tra chức năng trả về một lỗi. Chức năng chính in Tên hợp lệ nếu tên kiểm tra hàm trả về con số không.
đầu ra
2: Hàm Errorf()
Các Errorf() chức năng trong Go cũng cho phép chúng tôi xử lý các lỗi. Errorf() cung cấp cho chúng tôi tùy chọn định dạng thông báo lỗi. Bằng cách nhập gói fmt, nhà phát triển có thể sử dụng nó để tùy chỉnh các thông báo lỗi cho phù hợp với nhu cầu của họ. Errorf() hợp lý hóa và cải thiện hiệu quả của việc quản lý và chuyển lỗi trong Go.
gói chínhnhập khẩu 'fmt'
div chức năng ( n1, n2 bạn ) lỗi {
nếu như n2 == 0 {
trở lại fmt.Errorf ( '%d / %d \N Không thể chia một số cho 0' , n1, n2 )
}
trở lại không
}
chức năng chính ( ) {
lỗi := div ( 42 , 0 )
nếu như sai lầm ! = không {
fmt.Printf ( 'lỗi: %s' , lỗi )
} khác {
fmt.Println ( 'Phân chia hợp lệ' )
}
}
Trong đoạn mã trên, div hàm chấp nhận hai đầu vào số nguyên, n1 và n2 và nếu n2 bằng 0, nó sẽ tạo ra lỗi. Hàm tạo ra lỗi với thông báo chứa các giá trị của n1 và n2 nếu n2 bằng không. Hàm trả về nil để cho thấy rằng không có lỗi nếu n2 khác không.
Lỗi mà div trả về được lưu trong biến err khi hàm chính chạy div với các giá trị 42 và 0. Hàm chính sử dụng fmt.Printf để hiển thị thông báo lỗi nếu hàm div trả về lỗi. Chức năng chính in Phân chia hợp lệ nếu hàm div trả về nil.
đầu ra
3: Xử lý lỗi rõ ràng
Go khuyến khích quản lý lỗi rõ ràng so với các ngôn ngữ lập trình khác, thường dựa vào các ngoại lệ. Cách tiếp cận này khuyến khích các nhà phát triển sử dụng các câu lệnh if để kiểm tra lỗi một cách rõ ràng, thay vì dựa vào các khối try-catch. Bằng cách này, các lỗi có nhiều khả năng được tìm thấy và khắc phục đúng cách. Để tạo điều kiện thuận lợi cho việc này, Go cung cấp nếu sai != nil câu lệnh, cho phép các nhà phát triển kiểm tra lỗi sau khi thực thi một chức năng và thực hiện các hành động thích hợp dựa trên kết quả. Với khả năng xử lý lỗi rõ ràng, Go cung cấp một cách tiếp cận có cấu trúc và đáng tin cậy hơn để quản lý lỗi.
gói chínhnhập khẩu 'fmt'
chia hàm ( a, b float64 ) ( float64, lỗi ) {
nếu như b == 0 {
trở lại 0 , fmt.Errorf ( 'không thể chia cho số không' )
}
trở lại Một / b, không
}
chức năng chính ( ) {
kết quả, err := chia ( 13 , 3 )
nếu như sai lầm ! = không {
fmt.Printf ( 'Lỗi: %v \N ' , lỗi )
} khác {
fmt.Printf ( 'Kết quả: %f \N ' , kết quả )
}
kết quả, err = chia ( 23 , 0 )
nếu như sai lầm ! = không {
fmt.Printf ( 'Lỗi: %v \N ' , lỗi )
} khác {
fmt.Printf ( 'Kết quả: %f \N ' , kết quả )
}
}
Trong hình minh họa này, hàm chia được sử dụng để chia hai giá trị. Đầu ra là kết quả của việc làm như vậy. Nếu số thứ hai là 0, hàm sẽ tạo ra lỗi với thông báo lỗi rõ ràng.
Phép chia được gọi hai lần trong hàm chính: một lần với đầu vào hợp lệ và một lần với đầu vào không hợp lệ. các, nếu sai != không được sử dụng để xác định xem có lỗi xảy ra mỗi khi sử dụng hàm chia hay không. Một thông báo lỗi được in nếu xảy ra. Nếu không, kết quả được in ra.
đầu ra
4: Trì hoãn, hoảng loạn và phục hồi
Golang cũng cung cấp hoãn lại câu lệnh, được sử dụng để thực thi một chức năng sau khi hoàn thành chương trình hoặc một khối mã cụ thể. Các hoãn lại tuyên bố thường được sử dụng kết hợp với hồi phục chức năng bắt và khôi phục từ các lỗi hoảng loạn trong thời gian chạy. Khi một lỗi hoảng loạn thời gian chạy xảy ra, hồi phục chức năng được sử dụng để khôi phục từ tình trạng lỗi và ngăn chương trình bị sập. Điều này hữu ích cho các tác vụ dọn dẹp như đóng tệp, đóng kết nối mạng hoặc giải phóng tài nguyên. Bằng cách trì hoãn các tác vụ này, bạn đảm bảo rằng chúng sẽ được thực thi ngay cả khi xảy ra lỗi.
Các hoảng loạn được sử dụng để dừng thực thi bình thường của chương trình khi xảy ra lỗi không mong muốn, trong khi hồi phục được sử dụng để xử lý hoảng loạn và tiếp tục thực hiện chương trình.
gói chínhnhập khẩu 'fmt'
khôi phục chức năngFromPanic ( ) {
nếu như r := phục hồi ( ) ; r ! = không {
fmt.Println ( 'Hồi phục sau cơn hoảng loạn:' , r )
}
}
chia hàm ( x, y float64 ) phao64 {
trì hoãn phục hồiFromPanic ( )
nếu như và == 0 {
hoảng loạn ( 'không thể chia cho số không' )
}
trở lại x / Và
}
chức năng chính ( ) {
fmt.Println ( chia ( 13 , 3 ) )
fmt.Println ( chia ( 23 , 0 ) )
}
Trong đoạn mã trên, hàm chia được sử dụng để chia hai giá trị dấu phẩy động. Đầu ra là kết quả của việc làm như vậy. Một thông báo lỗi tùy chỉnh được xuất ra bởi hàm nếu số thứ hai bằng không. Câu lệnh defer được sử dụng để gọi recoveryFromPanic chức năng. Các recoveryFromPanic chức năng sẽ phát hiện sự hoảng loạn đã xảy ra bên trong chức năng phân chia và in lỗi nếu nó xảy ra.
Phép chia được gọi hai lần trong hàm chính: một lần với đầu vào hợp lệ và một lần với đầu vào không hợp lệ. Các fmt.Println hàm in đầu ra của hàm mỗi khi chạy hàm chia. Các recoveryFromPanic sẽ phát hiện sự hoảng loạn nếu xảy ra và in lỗi nếu xảy ra.
đầu ra
Sau khi phát hiện ra lỗi, chương trình đã thoát khỏi hoảng loạn và tiếp tục chạy. Tuy nhiên, mã bị hoảng loạn và không trả về giá trị trong lần gọi thứ hai để chia, đó là lý do tại sao nó trả về số không.
5: Gói lỗi
Go cũng bao gồm một tính năng được gọi là Lỗi gói , cho phép bạn thêm ngữ cảnh bổ sung vào thông báo lỗi. Điều này hữu ích để ghi lại sự cố hoặc cung cấp thêm chi tiết trong thông báo lỗi. Điều này có thể được thực hiện bằng cách tạo một loại lỗi nhúng lỗi ban đầu và ngữ cảnh bổ sung.
gói chínhnhập khẩu 'lỗi'
nhập khẩu 'fmt'
chức năng chính ( ) {
nếu như lỗi := thanh ( ) ; sai lầm ! = không {
fmt.Println ( sai lầm )
}
}
chia hàm ( a, b float64 ) ( float64, lỗi ) {
nếu như b == 0 {
trở lại 0 , lỗi.Mới ( 'chia cho số không' )
}
trở lại Một / b, không
}
thanh chức năng ( ) ( lỗi sai ) {
_, err = chia ( 42 , 0 )
nếu như sai lầm ! = không {
trở lại fmt.Errorf ( 'không tính được: %w' , lỗi )
}
trở lại không
}
Trong đoạn mã trên, hàm chia tính toán tỷ lệ của hai số trong ví dụ này và đưa ra lỗi nếu giá trị thứ hai bằng không. Hàm thanh gọi hàm phân chia và sau đó kết thúc lỗi đó chia trả về một lỗi mới với một thông báo bao gồm thông báo lỗi ban đầu bằng cách sử dụng hàm fmt.Errorf. Hàm bar được gọi bởi hàm chính, hàm này cũng in bất kỳ lỗi nào mà nó trả về.
đầu ra
Phần kết luận
Phát triển phần mềm phải bao gồm xử lý lỗi và Golang có nhiều chức năng và phương thức tích hợp sẵn khác nhau để thực hiện điều đó một cách duyên dáng. Các cơ chế này cho phép các nhà phát triển nắm bắt và khôi phục lỗi, ngăn chặn sự cố chương trình và cung cấp thông báo lỗi đầy đủ thông tin cho người dùng cuối. Bằng cách sử dụng các cơ chế xử lý lỗi này một cách hiệu quả, các nhà phát triển có thể xây dựng các ứng dụng phần mềm mạnh mẽ, đáng tin cậy và hiệu quả.