Go xử lý lỗi dưới dạng giá trị (errors as values) như thế nào?

Question

Accepted Answer

Go **không có exception** cho các lỗi thông thường. Thay vào đó, lỗi là **giá trị** được trả về từ hàm (thường là giá trị trả về cuối cùng), và bên gọi **kiểm tra tường minh** chúng. Điều này khiến việc xử lý lỗi trở nên hiển nhiên, có chủ đích, và không thể âm thầm bỏ qua — một triết lý đặc trưng của Go.

## Kiểu error và pattern cốt lõi

```go
// `error` là một interface tích hợp sẵn: bất cứ thứ gì có method Error() string
type error interface {
    Error() string
}

// các hàm trả về (result, error) — error là nil khi thành công
func divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, errors.New("division by zero")   // tạo một error
    }
    return a / b, nil    // nil = không có lỗi
}

// pattern gọi phổ biến
result, err := divide(10, 0)
if err != nil {              // KIỂM TRA lỗi tường minh
    fmt.Println("error:", err)
    return
}
fmt.Println(result)
```

Kiểm tra `if err != nil { ... }` xuất hiện liên tục trong Go — mỗi thao tác có thể thất bại đều được theo sau bởi một kiểm tra lỗi tường minh. Sự dài dòng này là có chủ đích: lỗi luôn hiển nhiên và được xử lý ngay tại điểm gọi.

## Tạo error

```go
errors.New("something failed")                       // error đơn giản
fmt.Errorf("failed to process %s: %w", name, err)    // có định dạng, với WRAPPING (%w)
```

## Bọc (wrap) và kiểm tra error

```go
// %w BỌC một error bên dưới, giữ nguyên chuỗi lỗi
if err != nil {
    return fmt.Errorf("reading config: %w", err)   // thêm ngữ cảnh, giữ bản gốc
}

// unwrap và kiểm tra với errors.Is / errors.As
if errors.Is(err, os.ErrNotExist) { ... }          // kiểm tra một error cụ thể
var pathErr *os.PathError
if errors.As(err, &pathErr) { ... }                 // trích xuất một kiểu error cụ thể
```

Wrapping (`%w`) thêm ngữ cảnh khi lỗi lan truyền lên, trong khi `errors.Is`/`errors.As` cho phép bạn kiểm tra hoặc trích xuất các lỗi bên dưới cụ thể — cách hiện đại để xử lý các chuỗi lỗi.

## Kiểu error tùy chỉnh

```go
type ValidationError struct {
    Field string
}
func (e *ValidationError) Error() string {           // hiện thực interface error
    return "invalid field: " + e.Field
}
return &ValidationError{Field: "email"}
```

## error vs panic

```text
error (giá trị) → các điều kiện DỰ KIẾN, có thể phục hồi (file thiếu, input sai) — thông thường
panic          → BẤT NGỜ, lỗi lập trình / không thể phục hồi (nil deref, out of bounds)
→ Dùng error cho xử lý thất bại thông thường; dành panic cho các trường hợp thực sự ngoại lệ.
```

## Tại sao điều này quan trọng

Cách tiếp cận lỗi-dưới-dạng-giá-trị của Go là một trong những đặc trưng nổi bật và gây tranh luận nhất, khác biệt cơ bản so với các ngôn ngữ dựa trên exception.

Bằng cách trả về lỗi dưới dạng giá trị mà bên gọi phải kiểm tra tường minh (`if err != nil`), Go khiến việc xử lý lỗi trở nên **hiển nhiên, cục bộ, và không thể vô tình bỏ qua** — bạn thấy chính xác nơi mỗi lỗi được xử lý, cải thiện độ tin cậy với cái giá là sự dài dòng.

Hiểu triết lý này, pattern `(result, error)`, wrapping lỗi (`%w`) với `errors.Is`/`errors.As` để thêm ngữ cảnh và kiểm tra chuỗi, các kiểu error tùy chỉnh, và sự phân biệt giữa error (thông thường, có thể phục hồi) và panic (ngoại lệ, lỗi lập trình) là tuyệt đối thiết yếu — nó thấm vào mọi chương trình Go và đại diện cho một sự chuyển đổi tư duy cốt lõi cho các lập trình viên đến từ các ngôn ngữ dựa trên exception.

Nó cũng nằm trong số các chủ đề phỏng vấn Go phổ biến nhất.