Interface hoạt động như thế nào trong Go?

Question

Accepted Answer

Một **interface** trong Go định nghĩa một tập các chữ ký method — một hợp đồng về hành vi. Quan trọng là interface được thỏa mãn một cách **ngầm định (implicitly)**: bất kỳ kiểu nào có các method đó đều tự động thỏa mãn interface, **không cần khai báo "implements" tường minh**. Cách tiếp cận theo cấu trúc, kiểu duck-typing này là đặc trưng và mạnh mẽ.

## Định nghĩa và hiện thực ngầm định một interface

```go
// định nghĩa một interface — một tập các chữ ký method
type Speaker interface {
    Speak() string
}

type Dog struct{}
func (d Dog) Speak() string { return "Woof" }   // Dog có Speak() → nó LÀ một Speaker

type Cat struct{}
func (c Cat) Speak() string { return "Meow" }   // Cat cũng vậy — ngầm định

// KHÔNG có "implements Speaker" ở bất cứ đâu — việc thỏa mãn là tự động
var s Speaker = Dog{}    // hoạt động vì Dog có method Speak()
s.Speak()                // "Woof"
```

Không có từ khóa `implements` — nếu một kiểu có tất cả các method của interface, nó tự động thỏa mãn interface. Điều này tách rời interface khỏi các hiện thực của nó (bên hiện thực thậm chí không cần biết interface tồn tại).

## Đa hình thông qua interface

```go
func announce(s Speaker) {        // nhận BẤT KỲ kiểu nào có Speak()
    fmt.Println(s.Speak())
}
announce(Dog{})    // "Woof"
announce(Cat{})    // "Meow"

speakers := []Speaker{Dog{}, Cat{}}   // một slice các kiểu khác nhau qua interface
for _, sp := range speakers { sp.Speak() }
```

Interface cho phép đa hình — viết code dựa trên hành vi, và bất kỳ kiểu nào tuân thủ đều hoạt động.

## Empty interface và `any`

```go
var x interface{}     // empty interface — được thỏa mãn bởi MỌI kiểu (không yêu cầu method)
x = 42
x = "hello"
// Go 1.18+: `any` là bí danh cho interface{}
func print(v any) { fmt.Println(v) }   // nhận bất cứ thứ gì
```

Empty interface (`interface{}` / `any`) giữ bất kỳ giá trị nào — dùng khi kiểu chưa biết trước (mặc dù generics giờ thường thay thế cho điều này).

## Các interface thư viện chuẩn bạn sẽ dùng liên tục

```go
type Stringer interface { String() string }   // kiểm soát việc in của fmt
type error interface { Error() string }        // chính kiểu error!
type io.Reader interface { Read(p []byte) (n int, err error) }
type io.Writer interface { Write(p []byte) (n int, err error) }
```

Phần lớn thư viện chuẩn được xây dựng trên các interface nhỏ (`io.Reader`/`io.Writer`, `error`, `Stringer`) — hiện thực chúng khiến các kiểu của bạn hoạt động với toàn bộ hệ sinh thái.

## Idiom: nhận interface, trả về struct

```text
Go ưa interface NHỎ (thường một method) được định nghĩa nơi chúng được DÙNG (bên tiêu thụ),
không phải nơi các kiểu được định nghĩa. "Interface càng lớn, abstraction càng yếu."
```

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

Interface là trung tâm trong thiết kế của Go và cách tiếp cận của nó với abstraction và đa hình — và việc **thỏa mãn ngầm định** (không có từ khóa `implements`; kiểu theo cấu trúc) là một trong những tính năng đặc trưng và mạnh mẽ nhất của ngôn ngữ.

Sự tách rời này nghĩa là kiểu và interface tiến hóa độc lập, bạn có thể định nghĩa interface *sau* các kiểu thỏa mãn nó, và bất kỳ kiểu nào tuân thủ đều tự động cắm vào code dựa-trên-interface — cho phép các thiết kế linh hoạt, ít ràng buộc và việc test dễ dàng (thay vào các hiện thực mock).

Hiểu hiện thực ngầm định, đa hình qua interface, empty interface/`any`, idiom interface-nhỏ ("nhận interface, trả về struct"), và các interface thư viện chuẩn phổ biến (`error`, `io.Reader`/`Writer`, `Stringer`) là thiết yếu cho Go idiomatic.

Đây là một chủ đề phỏng vấn thường gặp chính vì mô hình ngầm định, theo cấu trúc này khác biệt cơ bản so với interface tường minh của Java/C#.

Định nghĩa và hiện thực ngầm định một interface

Đa hình thông qua interface

Empty interface và any

Các interface thư viện chuẩn bạn sẽ dùng liên tục

Idiom: nhận interface, trả về struct

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

Empty interface và `any`