Type assertion và type switch là gì?

Question

Accepted Answer

Một **type assertion** trích xuất kiểu cụ thể từ một giá trị interface, và một **type switch** rẽ nhánh dựa trên kiểu nền tảng của một interface. Chúng là cách bạn khôi phục thông tin kiểu cụ thể từ một interface (đặc biệt là empty interface / `any`).

## Type assertion — trích xuất một kiểu cụ thể

```go
var i interface{} = "hello"     // một interface giữ một string

s := i.(string)                  // khẳng định nó là một string → s = "hello"
fmt.Println(s)

n := i.(int)                     // ❌ PANIC — i không phải là int (assertion sai)
```

Cú pháp `i.(Type)` khẳng định rằng interface `i` giữ một giá trị của `Type` và trích xuất nó. Nhưng một assertion sai sẽ **panic** — nên thông thường bạn dùng dạng comma-ok an toàn.

## Dạng comma-ok an toàn

```go
s, ok := i.(string)
if ok {
    fmt.Println("it's a string:", s)   // ok = true, s = giá trị
} else {
    fmt.Println("not a string")         // ok = false, s = giá trị zero, KHÔNG panic
}
```

Dạng hai-giá-trị trả về giá trị cộng với một boolean — `ok` là false (thay vì panic) nếu assertion thất bại. **Luôn ưu tiên dạng này** trừ khi bạn chắc chắn về kiểu.

## Type switch — rẽ nhánh trên nhiều kiểu có thể

```go
func describe(i interface{}) string {
    switch v := i.(type) {           // dạng .(type) đặc biệt, chỉ trong một switch
    case int:
        return fmt.Sprintf("int: %d (doubled: %d)", v, v*2)
    case string:
        return fmt.Sprintf("string of length %d", len(v))
    case bool:
        return fmt.Sprintf("bool: %t", v)
    case nil:
        return "nil value"
    default:
        return fmt.Sprintf("unknown type: %T", v)
    }
}

describe(42)        // "int: 42 (doubled: 84)"
describe("hi")      // "string of length 2"
```

Dạng `switch v := i.(type)` kiểm tra kiểu nền tảng và gắn `v` (có kiểu phù hợp trong mỗi case). Đây là cách sạch sẽ để xử lý một interface có thể giữ nhiều kiểu.

## Khẳng định cả các kiểu interface

```go
// khẳng định rằng một giá trị hiện thực một interface cụ thể
if w, ok := i.(io.Writer); ok {
    w.Write([]byte("data"))    // dùng nó như một io.Writer nếu nó thỏa mãn interface đó
}
```

## Khi nào bạn cần những thứ này

```text
✓ Xử lý các giá trị kiểu không biết (interface{}/any) — JSON, generic handler
✓ Kiểm tra xem một giá trị có hiện thực một interface tùy chọn không (ví dụ io.Closer)
✓ Xử lý dữ liệu không đồng nhất
⚠️ Thường là dấu hiệu bạn có thể dùng generics hoặc interface định kiểu tốt hơn — đừng lạm dụng
```

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

Type assertion và type switch là các công cụ thiết yếu để làm việc với các giá trị interface — khôi phục thông tin kiểu cụ thể từ `interface{}`/`any` hoặc kiểm tra xem một giá trị có thỏa mãn một interface cụ thể không.

Chúng cần thiết khi xử lý dữ liệu kiểu không biết hoặc đa dạng (parse JSON động, xử lý generic, kiểm tra interface tùy chọn như "cái này có hiện thực io.Closer không?").

Hiểu **sự phân biệt panic-vs-an-toàn** là then chốt: một assertion thường `i.(T)` panic khi không khớp, trong khi **dạng comma-ok** `v, ok := i.(T)` báo cáo thất bại một cách an toàn — dùng dạng an toàn là một thực hành then chốt để tránh crash runtime.

Type switch xử lý nhiều kiểu có thể một cách thanh lịch.

Biết những điều này (và rằng việc dùng nhiều thường báo hiệu bạn nên dùng generics hoặc các thiết kế định kiểu tốt hơn) là quan trọng cho Go an toàn, idiomatic và là một chủ đề phỏng vấn phổ biến, vì interface và empty interface rất trung tâm trong ngôn ngữ.