# Interface Go Nâng Cao 2026: Composition, Type Assertion và Câu Hỏi Phỏng Vấn

> Hướng dẫn chuyên sâu về interface Go hiện đại: composition interface, type assertion an toàn, generic tự tham chiếu, và các câu hỏi phỏng vấn thường gặp cho lập trình viên Go.

- Published: 2026-09-10
- Updated: 2026-09-10
- Author: Anthony Fillion-Maillet
- Tags: go, interfaces, generics, type-assertion, interview
- Reading time: 12 min

---

Interface Go định nghĩa hành vi mà không quy định cách triển khai, khiến chúng trở thành trung tâm của việc viết code linh hoạt và dễ kiểm thử. Go 1.26 mở rộng sức mạnh này với generic tự tham chiếu, iterator reflection mới, và xử lý lỗi type-safe thông qua `errors.AsType`. Hướng dẫn này bao gồm composition interface, type assertion, các pattern embedding, và những câu hỏi thường xuất hiện trong phỏng vấn kỹ thuật.

> **Cải Tiến Interface Go 1.26**
>
> Các kiểu generic giờ đây có thể tham chiếu đến chính nó trong danh sách tham số kiểu: `type Adder[A Adder[A]] interface { Add(A) A }`. Pattern F-bounded polymorphism này cho phép interface ràng buộc kiểu trả về là chính kiểu đang triển khai.

## Composition Interface và Các Pattern Embedding

Embedding interface kết hợp nhiều interface thành một contract duy nhất. Kết quả là một interface mới yêu cầu tất cả các method từ các interface được embed. Pattern này tránh trùng lặp và tạo ra ranh giới trừu tượng rõ ràng.

```go
// interfaces.go
type Reader interface {
    Read(p []byte) (n int, err error)
}

type Writer interface {
    Write(p []byte) (n int, err error)
}

type Closer interface {
    Close() error
}

// Interface composition embedding ba interface
type ReadWriteCloser interface {
    Reader
    Writer
    Closer
}
```

Bất kỳ kiểu nào triển khai các method `Read`, `Write`, và `Close` tự động thỏa mãn `ReadWriteCloser`. [Thư viện chuẩn Go](https://pkg.go.dev/io) sử dụng pattern này rộng rãi trong package `io`.

Một câu hỏi phỏng vấn phổ biến yêu cầu ứng viên giải thích tại sao Go ưu tiên các interface nhỏ và tập trung. Câu trả lời nằm ở tính composability: `io.Reader` xuất hiện trong hàng trăm hàm vì nó chỉ yêu cầu đúng một method. Các interface lớn hơn tạo ra coupling chặt hơn và giảm khả năng tái sử dụng.

## Type Assertion: Cú Pháp và An Toàn

Type assertion trích xuất kiểu cụ thể từ giá trị interface. Dạng hai giá trị ngăn panic bằng cách trả về boolean cho biết thành công hay không.

```go
// assertions.go
func processValue(v interface{}) {
    // Assertion hai giá trị: an toàn, không panic
    if str, ok := v.(string); ok {
        fmt.Printf("Giá trị string: %s\n", str)
        return
    }
    
    // Type switch cho nhiều kiểu
    switch val := v.(type) {
    case int:
        fmt.Printf("Integer: %d\n", val)
    case float64:
        fmt.Printf("Float: %.2f\n", val)
    case []byte:
        fmt.Printf("Bytes: %x\n", val)
    default:
        fmt.Printf("Kiểu không xác định: %T\n", val)
    }
}
```

Type switch xử lý nhiều kiểu một cách gọn gàng. Mỗi case bind `val` với kiểu đã assert trong block của nó, loại bỏ nhu cầu assertion riêng biệt.

> **Rủi Ro Panic**
>
> Assertion một giá trị như `str := v.(string)` sẽ panic nếu assertion thất bại. Code production nên luôn sử dụng dạng hai giá trị hoặc type switch.

Nhà tuyển dụng thường hỏi về hiệu năng của type assertion. Runtime thực hiện một phép so sánh type descriptor duy nhất, làm cho assertion không tốn kém. Chi phí tăng với các giá trị interface bọc pointer đến struct lớn do indirection, nhưng bản thân assertion vẫn là O(1).

## Generic Tự Tham Chiếu trong Go 1.26

Go 1.26 giới thiệu tham số kiểu tự tham chiếu, cho phép interface mà các method phải trả về kiểu đang triển khai. Pattern này, đôi khi được gọi là [F-bounded polymorphism](https://en.wikipedia.org/wiki/Bounded_quantification#F-bounded_quantification), giải quyết một hạn chế tồn tại lâu dài.

```go
// builder.go
// Interface tự tham chiếu: method trả về cùng kiểu
type Builder[B Builder[B]] interface {
    WithName(name string) B
    WithAge(age int) B
    Build() string
}

type PersonBuilder struct {
    name string
    age  int
}

func (p PersonBuilder) WithName(name string) PersonBuilder {
    p.name = name
    return p
}

func (p PersonBuilder) WithAge(age int) PersonBuilder {
    p.age = age
    return p
}

func (p PersonBuilder) Build() string {
    return fmt.Sprintf("%s, %d tuổi", p.name, p.age)
}

// Hàm generic sử dụng constraint tự tham chiếu
func configure[B Builder[B]](b B, name string, age int) string {
    return b.WithName(name).WithAge(age).Build()
}
```

Constraint `Builder[B]` đảm bảo rằng `WithName` và `WithAge` trả về `B`, không phải generic `Builder`. Nếu không có điều này, kiểu trả về sẽ là interface, mất thông tin kiểu cụ thể và phá vỡ method chaining.

Các kiểu toán học được hưởng lợi từ pattern này. Interface `Addable[A Addable[A]]` đảm bảo `Add(A) A` trả về cùng kiểu số, ngăn việc trộn lẫn các giá trị `BigInt` và `Decimal` một cách vô tình.

## errors.AsType: Error Unwrapping Type-Safe

Go 1.26 thêm [`errors.AsType`](https://pkg.go.dev/errors#AsType), thay thế pattern pointer-dance của `errors.As`. Phiên bản generic trả về error đã unwrap trực tiếp.

```go
// errors_handling.go
type ValidationError struct {
    Field   string
    Message string
}

func (e *ValidationError) Error() string {
    return fmt.Sprintf("xác thực thất bại trên %s: %s", e.Field, e.Message)
}

func handleError(err error) {
    // Go 1.26: generic type-safe unwrapping
    if valErr, ok := errors.AsType[*ValidationError](err); ok {
        log.Printf("Lỗi xác thực trên field %s\n", valErr.Field)
        return
    }
    
    // Trước Go 1.26: pointer-based unwrapping
    // var valErr *ValidationError
    // if errors.As(err, &valErr) { ... }
    
    log.Printf("Lỗi không mong đợi: %v\n", err)
}
```

API mới loại bỏ việc khai báo biến riêng biệt và làm cho kiểu đích rõ ràng trong lời gọi hàm. Error chain được tìm kiếm theo cách tương tự như trước; chỉ interface thay đổi.

## Iterator Reflection để Kiểm Tra Interface

Go 1.26 thêm các method iterator vào package `reflect`. `Type.Methods()` và `Value.Methods()` trả về iterator để ranging qua các method, thay thế vòng lặp dựa trên index.

```go
// reflection.go
import "reflect"

func inspectInterface(v interface{}) {
    t := reflect.TypeOf(v)
    
    // Go 1.26: kiểm tra method dựa trên iterator
    fmt.Printf("Các method của kiểu %s:\n", t.Name())
    for method := range t.Methods() {
        fmt.Printf("  %s: %s\n", method.Name, method.Type)
    }
    
    // Cho field struct (cũng mới trong 1.26)
    if t.Kind() == reflect.Struct {
        for field := range t.Fields() {
            fmt.Printf("  Field: %s (%s)\n", field.Name, field.Type)
        }
    }
}
```

Pattern iterator phù hợp với tính năng range-over-function của Go 1.23. Code trở nên dễ đọc hơn, và không có penalty về hiệu năng: iterator yield giá trị một cách lazy.

## Kiểm Tra Interface Satisfaction tại Compile Time

Go kiểm tra interface satisfaction tại compile time khi gán giá trị cụ thể cho biến interface. Kiểm tra tường minh sử dụng blank identifier assignment bắt lỗi sớm trong codebase lớn.

```go
// compile_check.go
type Storage interface {
    Save(key string, data []byte) error
    Load(key string) ([]byte, error)
    Delete(key string) error
}

type FileStorage struct {
    basePath string
}

// Kiểm tra compile-time: thất bại nếu FileStorage thiếu method
var _ Storage = (*FileStorage)(nil)

func (f *FileStorage) Save(key string, data []byte) error {
    path := filepath.Join(f.basePath, key)
    return os.WriteFile(path, data, 0644)
}

func (f *FileStorage) Load(key string) ([]byte, error) {
    path := filepath.Join(f.basePath, key)
    return os.ReadFile(path)
}

func (f *FileStorage) Delete(key string) error {
    return os.Remove(filepath.Join(f.basePath, key))
}
```

Dòng `var _ Storage = (*FileStorage)(nil)` chỉ compile nếu `*FileStorage` thỏa mãn `Storage`. Pattern này bắt các method thiếu ngay lập tức thay vì tại runtime khi giá trị được gán.

## Empty Interface và Type Constraint

Empty interface `interface{}` chấp nhận bất kỳ giá trị nào, trong khi `any` là alias của nó từ Go 1.18. Generic constraint cung cấp type safety tại compile time mà không cần runtime assertion.

```go
// constraints.go
import "golang.org/x/exp/constraints"

// Hàm generic với constraint số
func Sum[T constraints.Integer | constraints.Float](values []T) T {
    var total T
    for _, v := range values {
        total += v
    }
    return total
}

// Constraint comparable cho map key
func Contains[K comparable, V any](m map[K]V, key K) bool {
    _, exists := m[key]
    return exists
}
```

Ưu tiên generic hơn `interface{}` loại bỏ type assertion và bắt type mismatch tại compile time. Trade-off là thêm độ phức tạp trong signature hàm, vì vậy generic phù hợp nhất khi hàm thực sự hoạt động trên nhiều kiểu.

## Câu Hỏi Phỏng Vấn Kỹ Thuật về Interface Go

Nhà tuyển dụng kiểm tra kiến thức interface ở nhiều cấp độ. Dưới đây là các câu hỏi phổ biến với câu trả lời ngắn gọn.

**H: Điều gì xảy ra khi gọi method trên giá trị interface nil so với giá trị cụ thể nil bên trong interface?**

Interface nil không có kiểu và không có giá trị; gọi bất kỳ method nào sẽ panic. Interface non-nil chứa pointer nil có kiểu; method được thực thi với receiver nil. Hành vi này cho phép các pattern như `(*bytes.Buffer)(nil).String()` trả về string rỗng.

**H: So sánh interface hoạt động như thế nào?**

Hai giá trị interface bằng nhau nếu chúng có cùng dynamic type và dynamic value bằng nhau. So sánh interface với các kiểu không comparable (slice, map, function) sẽ panic tại runtime.

**H: Khi nào method nên sử dụng pointer receiver so với value receiver?**

Pointer receiver cho phép mutation và tránh copy struct lớn. Value receiver an toàn cho concurrent use và hoạt động với cả value và pointer. Nếu bất kỳ method nào cần pointer receiver, tất cả method trên kiểu đó nên sử dụng pointer receiver để nhất quán, vì chỉ `*T` thỏa mãn interface yêu cầu method pointer-receiver.

```go
// receiver_rules.go
type Counter struct {
    count int
}

// Pointer receiver: modify struct
func (c *Counter) Increment() {
    c.count++
}

// Value receiver: read-only operation
func (c Counter) Value() int {
    return c.count
}

type Incrementer interface {
    Increment()
}

func main() {
    var c Counter
    // var i Incrementer = c  // Lỗi compile: Counter thiếu Increment
    var i Incrementer = &c     // OK: *Counter có Increment
    i.Increment()
}
```

**H: Giải thích nguyên tắc "accept interfaces, return structs".**

Hàm chấp nhận interface tách biệt khỏi implementation cụ thể, cho phép testing với mock. Trả về kiểu cụ thể cho phép caller truy cập đầy đủ các method của kiểu mà không cần type assertion. Trả về interface ẩn các method addition trong tương lai sau type assertion.

Để chuẩn bị phỏng vấn Go thêm, xem module [câu hỏi concurrency Go](/technologies/go/interview-questions/concurrency-patterns) và [module testing](/technologies/go/interview-questions/testing).

> **Mẹo Phỏng Vấn**
>
> Khi được yêu cầu thiết kế interface, bắt đầu với trường hợp single-method. Mở rộng chỉ khi nhiều method luôn được gọi cùng nhau. Các interface `Stringer`, `Reader`, và `Handler` của thư viện chuẩn mỗi cái định nghĩa một method.

## Những Điều Developer Go Senior Cần Biết về Interface

- Composition interface thông qua embedding tạo contract linh hoạt mà không có hệ thống phân cấp inheritance. Giữ interface nhỏ: một đến ba method đủ cho hầu hết use case.
- Type assertion và type switch trích xuất kiểu cụ thể một cách an toàn. Luôn sử dụng dạng hai giá trị hoặc switch trong code production để tránh panic.
- Generic tự tham chiếu của Go 1.26 cho phép builder pattern và kiểu toán học mà method phải trả về kiểu đang triển khai.
- `errors.AsType` đơn giản hóa error unwrapping với API generic, type-safe. Sử dụng trong code mới nhắm đến Go 1.26 trở lên.
- Kiểm tra interface compile-time với `var _ Interface = (*Type)(nil)` bắt method thiếu trước khi test chạy.
- Ưu tiên generic hơn `interface{}` khi type safety tại compile time quan trọng hơn độ phức tạp signature.
- Hướng dẫn "accept interfaces, return structs" giữ API linh hoạt cho caller trong khi expose đầy đủ chức năng.

---

Source: SharpSkill (https://sharpskill.dev), tech interview preparation for your real stack.
HTML version of this page: https://sharpskill.dev/vi/blog/go/go-interfaces-advanced-composition-type-assertions-2026