Có một giai đoạn trong Go mà mỗi lần cần hàm "lấy giá trị lớn nhất" cho kiểu dữ liệu mới, mình lại copy-paste thêm một bản: MaxInt, MaxFloat, MaxString, rồi MaxPrice, MaxDuration. Logic y chang, chỉ khác chữ ký hàm. Vài tháng sau, ai sửa bug trong MaxInt cũng quên sửa MaxFloat.

Trước Go 1.18, không có cách gọn cho chuyện này. Dân Go hoặc dùng interface{} rồi ép kiểu bằng tay, hoặc sinh code bằng công cụ, hoặc cắm đầu copy-paste kèm lời hứa "sẽ dọn sau" — mà sau không bao giờ tới. Từ Go 1.18, generics vào sân. Nhưng nó cũng mang theo một mớ bẫy mà ai mới chuyển từ Java hay TypeScript sang hay dính.

Generics không phải là "bản gọn hơn của interface{}"

Sai lầm phổ biến nhất là nghĩ generics chỉ là cách viết ngắn hơn của interface{}. Hai thứ này giải hai bài toán khác nhau.

any là trốn kiểu dữ liệu. Nhét gì cũng được, nhưng lúc lấy ra phải kiểm tra kiểu lúc chạy (type assertion). Sai kiểu thì panic hoặc trả false. Máy không giúp bạn gì.

Generics là giữ kiểu dữ liệu, chỉ hoãn quyết định "kiểu nào" đến lúc gọi hàm. Trình biên dịch vẫn kiểm tra hết, sai kiểu là báo lỗi ngay ở bước build.

Bản interface{} mà mình thấy nhiều người viết:

func MaxAny(items []any) any {
    max := items[0]
    for _, v := range items[1:] {
        if v.(float64) > max.(float64) { // vỡ ngay với []time.Duration
            max = v
        }
    }
    return max
}

Bản generics thì gọn và an toàn hơn hẳn:

func Max[T int | float64 | string](items []T) T {
    var zero T // zero value của T, không cần biết T là kiểu gì
    if len(items) == 0 {
        return zero
    }
    max := items[0]
    for _, v := range items[1:] {
        if v > max {
            max = v
        }
    }
    return max
}

Gọi Max([]int{3, 9, 2}) hay Max([]string{"a", "z"}) đều được, trình biên dịch tự suy ra T từ tham số.

Constraint là phần lõi, đừng bỏ qua

Có hai thứ mới trong cú pháp: type parameter (T trong ngoặc vuông) và constraint (int | float64 | string đứng sau T). Constraint mới là cái quan trọng — nó vừa giới hạn kiểu nào được lọt vào, vừa quyết định những phép toán nào bạn được dùng trên T.

Nhìn bản Max: dùng được v > max vì constraint chỉ chứa kiểu có toán tử so sánh. Nếu constraint là any, câu đó không biên dịch được. Trình biên dịch đứng ở góc nhìn "T có thể là bất cứ gì" và từ chối ngay. Đó là cái hay: constraint ép bạn khai báo rõ ý định.

Ngoài dạng liệt kê, Go còn có dấu ~ (tilde). Viết ~int nghĩa là "kiểu int, hoặc bất kỳ kiểu tự định nghĩa nào dựa trên int". Cực hữu ích khi bạn có kiểu alias:

type Celsius float64
type Fahrenheit float64

func MaxTemp[T ~float64](temps []T) T {
    max := temps[0]
    for _, t := range temps[1:] {
        if t > max {
            max = t
        }
    }
    return max
}

Không có ~ thì phải liệt kê từng kiểu custom, và mỗi lần ai thêm kiểu mới lại phải mò vào sửa constraint.

Còn một constraint mặc định cần nhớ: comparable. Muốn dùng == hay làm key trong map[T]V, T phải thoả comparable. Go chặn trước vì struct có field slice bên trong thì so sánh không hợp lệ.

Dọn đám helper — chỗ generics đáng tiền nhất

Giá trị rõ nhất không nằm ở thuật toán mới, mà ở việc dọn helper lặp. Mình từng có 7 hàm kiểu ContainsInt, ContainsString, IndexOfStatus... Chuyển hết sang generics thì gọn còn mấy hàm:

func Contains[T comparable](items []T, target T) bool {
    for _, v := range items {
        if v == target {
            return true
        }
    }
    return false
}

func Map[T, U any](items []T, f func(T) U) []U {
    out := make([]U, len(items))
    for i, v := range items {
        out[i] = f(v)
    }
    return out
}

func Filter[T any](items []T, keep func(T) bool) []T {
    var out []T // không đụng backing array của slice gốc
    for _, v := range items {
        if keep(v) {
            out = append(out, v)
        }
    }
    return out
}

Contains dùng comparable, còn Map/Filter dùng any vì không so sánh gì. Không phải chuyện "cứ any cho khoẻ" — constraint sai sẽ lộ ngay lúc compile, nên tội gì nới quá rộng.

Một bẫy nhỏ: nếu Filter viết out := items[:0] cho tiết kiệm cấp phát, kết quả sẽ ghi đè lên slice gốc (dùng chung backing array). Rất nhiều người dính cái này.

Generic struct: chỉ khi struct thật sự mang kiểu dữ liệu

Generics không chỉ dành cho hàm. Nhưng đây là chỗ dễ sinh ra "generic vô tội vạ" — thứ làm code khó đọc hơn chứ không dễ hơn.

Hợp lý nhất là khi struct chứa dữ liệu kiểu T: Node[T], Stack[T], Result[T], Cache[K, V]. Ví dụ cache TTL mình dùng trong một service nhỏ:

type TTLCache[K comparable, V any] struct {
    mu   sync.Mutex
    data map[K]cacheEntry[V]
    ttl  time.Duration
}

func (c *TTLCache[K, V]) Get(key K) (V, bool) {
    c.mu.Lock()
    defer c.mu.Unlock()

    var zero V
    entry, ok := c.data[key]
    if !ok || time.Now().After(entry.expiredAt) {
        return zero, false
    }
    return entry.value, true
}

Bài toán ở đây rõ: một cache dùng cho nhiều kiểu value, khỏi viết cacheInt, cacheStruct riêng. Không dùng interface{} vì bên gọi lại phải assert kiểu mỗi lần Get.

Ngược lại, đừng generic hoá khi struct chỉ có đúng một concrete type. Gặp hoài kiểu Repository[T] mà thực tế chỉ dùng Repository[User] — lúc đó generic chỉ khiến người đọc hỏi "T là cái chi, có lúc nào khác không?". Trả lời: không. Bỏ đi.

Ba bẫy compile mà mình đã vấp

Bẫy một: Go không có overload. Bạn không thể có Max(int, int) và Max(float, float) cùng tên. Chỉ có một Max[T] phải dùng được cho mọi kiểu trong constraint. Đôi khi điều đó buộc bạn nới constraint rộng hơn mong muốn — và thường thì viết thêm hàm riêng là lựa chọn đúng hơn.

Bẫy hai: Go suy luận được phần lớn trường hợp nhưng không phải tất cả. Có lúc phải gọi rõ Map[int, string](nums, strconv.Itoa). Gặp "cannot infer T" thì cứ gọi rõ kiểu. Nhưng nếu đoạn nào cũng phải gõ <A, B, C> thì signature đang quá tham lam — chia nhỏ hàm lại.

Bẫy ba: method của type generic không được có type parameter riêng. Không viết được func (c *Cache[K,V]) BulkGet[U any](keys []K) []U. Muốn thêm kiểu thứ ba thì dùng hàm tự do, không phải method.

Đọc thêm hai bài cùng chủ đề

Cái chuyện "giá trị vắng mặt" mà mình dùng var zero T ở trên cũng liên quan tới một bẫy Go rất hay gặp: interface nil trong Go — err != nil mà vẫn panic, đọc để thấy zero value với interface không đơn giản như tưởng.

Nếu bạn quan tâm constraint kiểu ở góc nhìn khắt khe hơn, Send và Sync trong Rust — vì sao Rc không qua được thread là ví dụ hay về đẩy ràng buộc lên compile time. Còn serde trong Rust: parse JSON không sập vì một field lạ cho thấy cùng triết lý "giữ kiểu đến cùng" nhưng thực thi ở tầng khác.

Khi nào dùng, khi nào bỏ qua

Sau một thời gian dùng hằng ngày, mình đúc kết mấy quy tắc:

  • Dùng khi: logic y chang nhau, khác nhau chỉ ở kiểu. Chiếm đa số trường hợp, generics thắng.
  • Bỏ qua khi: logic thay đổi theo kiểu (kiểu số cộng được, kiểu string nối được). Constraint rộng nhất cũng không giúp gì — dùng hàm riêng hoặc định nghĩa interface có method.
  • Không generic hoá sớm. Viết một hàm cho []User; khi có thêm []Order cùng logic mới refactor. Đổi sớm dễ biến hàm 10 dòng thành một đống <T, U, V> phải decode.
  • Không generic hoá để "sau này dùng". Bạn không biết tương lai. Generic hoá thứ chưa biết dùng cho kiểu nào là thêm noise.

Generics trong Go mạnh nhưng hẹp hơn nhiều người tưởng. Nó không phải Java generics, cũng không phải TypeScript generics. Nó là Go — cố tình hẹp, cố tình tường minh. Khi thấy nó đau, thường là dấu hiệu nó không phải công cụ phù hợp cho bài toán đó. Viết thêm hai hàm thường không phải tội.


📋 Phụ lục thuật ngữ

  • Type parameter (T, U, K, V): tên đại diện cho kiểu dữ liệu, chỉ biết cụ thể khi hàm được gọi. Quy ước: T cho kiểu chính, K/V cho map, U khi cần kiểu thứ hai.
  • Constraint: phần giới hạn kiểu giữa ngoặc vuông. Vừa kiểm soát kiểu nào được dùng, vừa cho phép những phép toán nào trên T.
  • any: alias của interface{} — không giới hạn kiểu, nhưng cũng không có phép toán nào dùng được ngoài gán.
  • comparable: constraint cho phép ==, !=, hoặc làm key trong map.
  • Tilde ~: prefix trong constraint, ví dụ ~int = "int hoặc bất kỳ kiểu tự định nghĩa có underlying type là int".
  • Type inference: trình biên dịch tự suy ra type parameter từ tham số truyền vào.

Xem các bài viết khác