Sửa lỗi 'reflect.Value.Interface: cannot return value obtained from unexported field' trong Go

Lỗi Gặp Phải

Bạn đang dùng package reflect của Go để kiểm tra một struct và gặp lỗi này:

panic: reflect.Value.Interface: cannot return value obtained from unexported field or method

goroutine 1 [running]:
reflect.Value.Interface(...)
        /usr/local/go/src/reflect/value.go:1032
main.main()
        /tmp/sandbox/main.go:18 +0x1a5

Lỗi này thường xuất hiện khi bạn duyệt qua các field của struct bằng reflection và gọi .Interface() — nhưng một trong các field đó bắt đầu bằng chữ thường.

Nguyên Nhân

Quy tắc visibility của Go không chỉ dừng lại ở compiler — package reflect cũng áp dụng chúng. Các unexported field (tên viết thường) là private trong phạm vi package. Code bên ngoài không thể truy cập trực tiếp, và reflect sẽ panic lúc runtime nếu bạn cố gắng làm vậy.

Đây là đoạn code tái hiện lỗi tối giản nhất:

package main

import (
    "fmt"
    "reflect"
)

type User struct {
    Name  string // exported
    email string // unexported
}

func main() {
    u := User{Name: "Alice", email: "alice@example.com"}
    v := reflect.ValueOf(u)

    for i := 0; i < v.NumField(); i++ {
        field := v.Field(i)
        fmt.Println(field.Interface()) // panics on 'email'
    }
}

Vòng lặp đến field thứ hai (email) và bị lỗi ngay. Tên viết thường là dấu hiệu nhận biết.

Cách Sửa Nhanh: Kiểm Tra CanInterface() Trước Khi Gọi Interface()

CanInterface() cho bạn biết liệu lệnh gọi có thành công không. Hãy bọc mọi lệnh gọi .Interface() bằng nó:

for i := 0; i < v.NumField(); i++ {
    field := v.Field(i)
    if !field.CanInterface() {
        continue // bỏ qua các unexported field
    }
    fmt.Println(field.Interface())
}

Hết panic. Pattern tương tự hoạt động dù bạn truy cập field theo tên hay đào sâu vào các struct lồng nhau.

Kiểm Tra Cả Tên Field

Cần ghi log những field đang bị bỏ qua? Kiểm tra PkgPath của từng field thông qua reflect.Type:

t := reflect.TypeOf(u)
v := reflect.ValueOf(u)

for i := 0; i < t.NumField(); i++ {
    ft := t.Field(i)
    fv := v.Field(i)

    if ft.PkgPath != "" {
        fmt.Printf("Skipping unexported field: %s\n", ft.Name)
        continue
    }

    fmt.Printf("%s = %v\n", ft.Name, fv.Interface())
}

PkgPath rỗng với các exported field. Với unexported field, nó chứa đường dẫn package định nghĩa — chẳng hạn main hoặc github.com/yourorg/pkg. Rất hữu ích khi bạn debug code serialization và muốn biết chính xác field nào bị bỏ qua.

Giải Pháp Lâu Dài: Xem Lại Thiết Kế Struct

Gặp panic này thường có nghĩa là reflection đang làm công việc mà nó không nên làm. Unexported field là private theo thiết kế. Dùng reflect để đọc chúng từ bên ngoài package là dấu hiệu API của struct cần được xem lại — không phải tìm cách giải quyết khéo léo hơn.

Phương án 1: Export các field cần thiết

Nếu một field thực sự thuộc về public interface, hãy viết hoa tên nó:

type User struct {
    Name  string
    Email string // trước là 'email', giờ đã exported
}

Đây là phương án gọn nhất khi dữ liệu thuộc về public API của bạn.

Phương án 2: Implement custom marshaler hoặc accessor

Muốn giữ field private nhưng vẫn hỗ trợ serialization hoặc xử lý generic? Thêm method thay vì mở struct ra:

type User struct {
    Name  string
    email string
}

func (u User) ToMap() map[string]any {
    return map[string]any{
        "Name":  u.Name,
        "email": u.Email(), // truy cập có kiểm soát
    }
}

func (u User) Email() string {
    return u.email
}

Encapsulation vẫn nguyên vẹn. Không cần reflection.

Phương án 3: Dùng encoding/json tags

Bạn tự viết vòng lặp reflection để marshal struct? Đó chính là việc encoding/json sinh ra để làm — và nó đã tự động bỏ qua các unexported field một cách im lặng:

import "encoding/json"

type User struct {
    Name  string `json:"name"`
    email string // json package silently ignores this
}

data, _ := json.Marshal(User{Name: "Alice", email: "hidden"})
fmt.Println(string(data)) // {"name":"Alice"}

Trường Hợp Đặc Biệt: Pointer Tới Struct

Truyền pointer thay vì value? Hãy gọi .Elem() trước để dereference. Bỏ qua bước này và bạn sẽ gặp một panic khác trước khi kịp kiểm tra unexported field:

u := &User{Name: "Alice", email: "alice@example.com"}
v := reflect.ValueOf(u)

if v.Kind() == reflect.Ptr {
    v = v.Elem() // dereference pointer
}

for i := 0; i < v.NumField(); i++ {
    field := v.Field(i)
    if field.CanInterface() {
        fmt.Println(field.Interface())
    }
}

Kiểm Tra Kết Quả

Thêm guard CanInterface() và chạy lại code. Không còn panic nữa. Để kiểm tra xem field nào đang bị bỏ qua, thêm một dòng log:

for i := 0; i < v.NumField(); i++ {
    ft := t.Field(i)
    fv := v.Field(i)
    if !fv.CanInterface() {
        fmt.Printf("[skip] %s (unexported)\n", ft.Name)
        continue
    }
    fmt.Printf("%s = %v\n", ft.Name, fv.Interface())
}

Kết quả mong đợi với ví dụ User:

Name = Alice
[skip] email (unexported)

Muốn có regression test để đảm bảo không tái phát?

func TestReflectNoExportedPanic(t *testing.T) {
    u := User{Name: "Alice", email: "alice@example.com"}
    v := reflect.ValueOf(u)
    for i := 0; i < v.NumField(); i++ {
        field := v.Field(i)
        if field.CanInterface() {
            _ = field.Interface() // không được panic
        }
    }
}

Chạy với go test ./... — pass sạch.

Tóm Tắt

• Panic xảy ra khi bạn gọi .Interface() trên một reflect.Value từ unexported field của struct.
• Dùng field.CanInterface() để bỏ qua các field đó một cách an toàn.
• Dùng ft.PkgPath != "" qua reflect.Type để kiểm soát từng field một cách tường minh.
• Để sửa triệt để: export các field, thêm accessor method, hoặc dùng encoding/json — và tránh dùng reflection để truy cập trạng thái private.