Go Learn - Interface :: nfwyst's blog

假设我们正在开发一个图形应用程序，需要计算各种形状的面积，例如 Circle 和 Square 。随着应用程序的增长，我们引入了更多的形状，管理这些形状的代码也变得越来越复杂。考虑这种情况：

func getArea(shape any) (int, error) {
  switch shape.(type) {
    case Square:
      return shape.(Square).area(), nil
    case Circle:
      return shape.(Circle).area(), nil
    ...
    default:
      return 0, errors.New("unknown type")
  }
}

shape.(Square) 和 shape.(Circle) 分别将 shape 从 any 接口类型断言(恢复)为具体的 Square 和 Circle 类型. any 是 interface{} 的别名，可以接收任何类型

随着形状的增加，这类代码很快就会变得难以管理。有没有办法简化这个问题呢？Go 中的接口允许我们定义一组可供不同类型实现的方法。这种抽象允许我们将各种类型视为同一种接口类型，从而实现更加灵活和模块化的代码。通过定义一个带有 area() 方法的 Geometry 接口，我们可以在不同形状上实现它：

type Geometry interface {
    area() int
}

func (c Circle) area() int {
    return math.Pi * c.radius * c.radius
}

func (s Square) area() int {
    return s.side * s.side
}

现在，我们的 getArea() 函数变得更简单、更灵活：

func getArea(shape any) (int, error) {
    if g, ok := shape.(Geometry); ok {
      return g.area(), nil
    } else {
      return 0, errors.New("unknown type")
    }
}

类型断言返回两个值：转换后的值 g 和布尔值表示是否成功, 如果 ok 成功, 我们需要使用断言后的值 g 来调用 Geometry 接口的 area 方法, 这样，我们就可以避免使用特定类型的函数并简化我们的代码。

在本文中, 我们将:

探索如何定义和实现接口
了解接口如何增加灵活性和代码可重用性
了解类型断言, 类型开关, 以及使用接口时的最佳实践

定义接口⌗

Go 中的接口使用 type 关键字，后跟接口名称和关键字 interface 来定义。以下是我们如何定义一个处理车辆维护的接口：

type Maintainer interface {
    Service(vehicleID int) string
}

接口由方法签名组成。这些签名概述了类型必须实现的方法，指定了方法的名称、参数和返回类型，但没有指定方法的具体实现。

实现接口⌗

在 Go 中，我们通过定义接口的所有方法来实现它。我们隐式地实现接口，这意味着我们不需要专门声明一个实现了某个接口的类型。如果一个类型具有与接口中相同的方法签名，则它被视为该接口的实现。

接收者⌗

在 Go 中，方法绑定到接收者类型。接收者可以是值类型或指针类型，这会影响方法与数据的交互方式：

值接收者操作数据的副本。它们不会修改原始实例

// Here, the receiver is `ms` of type `MaintenanceService`.
func (ms MaintenanceService) Service(vehicleID int) string {
    location := ms.location
    return fmt.Sprintf("Vehicle %d has been serviced at %s.", vehicleID, location)
}

指针接收者可以修改原始数据实例，因为它们引用了内存地址

// Here, the receiver is a pointer receiver, `cs` of type `*CleaningService`
func (cs *CleaningService) Service(vehicleID int) string {
    cs.waterGallons--
    return fmt.Sprintf("Vehicle %d has been serviced.", vehicleID)
}

现在， MaintenanceService 和 CleaningService 都可以用作 Maintainer 。

接收者出现在 func 关键字和方法名之间的自己的参数列表中，类似于其他语言中的 this 或 self 关键字, 通常用一个或两个字母命名, 并根据接口类型分别确定接口实现, 要么是值接收者要么是指针接收者

[!TIP] 接口是隐式声明的, Go 不需要显式声明来实现接口。只要类型具有接口中指定的所有方法，Go 就认为该类型已实现。

使用接口⌗

考虑设计用于保存不同形状（例如正方形和矩形）的 Geometry 接口：

type Geometry interface {
    Area() int
}

为了利用 Geometry 接口，我们需要声明一个接口类型的变量，然后将其分配给不同的具体形状：

var shape Geometry

// `Square` and `Rectangle` implement the `Geometry` interface.
geometry = Square{ length: 4 }
geometry = Rectangle{ length: 3, width: 2 }

通过接口调用方法的语法与调用特定类型的方法相同。例如，检索存储在 geometry 中的当前形状的面积如下:

area := geometry.Area()

此调用将执行当前所代表的 geometry 几何的 Area 方法。

面向接口编程⌗

针对接口而非具体实现进行编程是软件开发的关键实践。这种做法鼓励使用通用接口而不是具体类型。针对接口进行编程的一些好处：

适应性：使代码较少依赖于特定的实现。
代码重用：减少复杂性和重复。
扩展和灵活性：无需进行大规模改造即可更轻松地进行更新和增长。

类型断言和开关⌗

类型断言和类型开关是 Go 中处理接口的强大工具, 当我们需要检索或验证接口变量的具体类型时，类型断言提供了一种从接口变量中恢复具体类型的方法，语法为 x.(T) ，其中 x 是变量， T 是我们断言的类型。

类型断言有两种形式：

安全: value, ok := x.(T) 返回一个布尔值 ok ，检查断言是否成功，避免运行时 panic。
不安全： value := x.(T) 尝试检索类型，如果 x 不是类型 T 则会引起运行时 panic。

注意：不安全类型断言适用于我们在运行时确定接口类型，并且希望避免检查类型的开销的情况。但是，应谨慎使用它们，因为如果我们的假设不正确，它们可能会导致运行时 panic。

类型开关扩展了这一概念，允许我们在单个操作中安全地处理多种类型。当接口变量可能表示多种具体类型时，类型开关非常有用。以下是类型开关的使用方法：

switch v := vehicle.(type) {
  case Car:
    fmt.Println("Handling a car of model:", v.model)
  case Bike:
    fmt.Println("Handling a bike of color:", v.color)
  default:
    fmt.Println("Unknown vehicle type")
}

在这个例子中， v := vehicle.(type) 执行类型断言并将结果赋值给 v 。然后，语句会根据每个 case 检查 v 类型是否与 Car 或 Bike 匹配，并执行相应的代码块。 default case 可作为未知类型的后备，确保程序能够优雅地处理这些类型。

注意：不处理默认情况不会导致异常，但将其包括在内以处理意外类型通常是一种很好的做法。类型开关实际上等价于多个 if-else 类型断言：

// 类型开关
switch v := vehicle.(type) {
case Car:
    fmt.Println("Car:", v.brand)
case Bike:
    fmt.Println("Bike:", v.wheels)
}

// 等价于
if v, ok := vehicle.(Car); ok {
    fmt.Println("Car:", v.brand)
} else if v, ok := vehicle.(Bike); ok {
    fmt.Println("Bike:", v.wheels)
}

空接口⌗

Go 中的空接口 interface{} 可以保存任何类型的值。这是因为 Go 中的所有类型都隐式实现了至少零个方法，这满足了空接口的条件。我们也可以使用 any 关键字来代替 interface{} 。

要声明空接口，请使用以下语法：

var value interface{}

当需要接受各种类型的参数时空接口在函数中很有用。例如，一个处理不同类型数据并执行特定类型操作的函数：

func processData(data any) {
  switch v := data.(type) {
  case string:
      fmt.Println("Processing string:", v)
  case int:
      fmt.Println("Processing integer:", v*2)
  case bool:
      fmt.Println("Processing boolean:", !v)
  default:
      fmt.Println("Unknown type")
  }
}

然而，使用空接口是有风险的。由于它可以容纳任何类型，我们会失去编译时类型检查，从而更难确保操作中的类型安全。要安全地检索和使用存储在空接口中的值的底层类型，请使用类型断言或开关。

最佳实践: 保持最小接口⌗

在 Go 中，接口通常很小，通常只有一两个方法，这使得它们更易于处理和维护。小型接口有几个好处：

简单性：它们保持系统简单，让开发人员只添加必要的内容。
灵活性：它们允许轻松混合和匹配功能。
组合：通过组合较小、较简单的接口可以构建较大、较复杂的接口。

例如，我们可以定义较小的接口，然后将它们组合起来，而不是创建用于读取和写入数据的大型接口：

type Reader interface {
    Read()
}

type Writer interface {
    Write()
}

type ReadWriter interface {
    Reader
    Writer
}

在此设置中，实现 ReadWriter 接口的类型必须同时满足 Reader 和 Writer 接口。这种模块化方法使开发人员能够在各种配置中组合这些接口。每种类型只需实现与其角色相关的方法。

此外，较小的接口通过保持各部分独立性，可以提升整个系统的运行效率。程序的每个部分只与其所需的接口交互，从而降低了复杂性。这种分离在我们需要更改或替换程序的某些部分而不影响其他部分时非常有用；我们称之为解耦。

最佳实践: 行为优于实现⌗

在 Go 中，定义接口最好专注于系统应该做什么，而不是如何做。这种方法使代码更加灵活，可重用性更强。当我们基于行为创建接口时，不同的类型可以唯一地实现相同的接口，从而增强代码重用性。

例如，考虑一个 Notifier 接口：

type Notifier interface {
    Notify(message string)
}

此灵活的接口支持多种通知方式，例如短信、电子邮件或推送通知。该接口指定了必须执行的操作（即通知），但没有指定如何操作。

但是，如果我们像这样定义接口：

type Notifier interface {
    SMSNotify(message string)
}

这可能是一个糟糕的设计，因为它指定了一种特定的通信方法，限制了实现选项。关注行为可以让不同的对象在同一接口下互换。具有抽象行为的接口往往随着时间的推移更加稳定。实现可以根据需要进行更改，而无需更改接口，从而简化了维护并降低了出现错误的可能性。

回顾与总结⌗

在 Go 中，接口是构建灵活且可维护的应用程序的一项基本技能。让我们回顾一下我们所学到的知识：

定义接口：在接口中定义一组不同类型可以实现的方法，从而允许它们互换使用。
实现接口：实现接口中的方法以隐式实现接口。
接收者：值接收者允许从类型读取数据。指针接收者允许修改数据。
使用接口：应用接口来创建灵活且可重用的代码。
类型断言和开关：安全地检索和验证接口变量的类型
空接口：使用空接口来保存任何类型的值。
保持接口小巧：采用小型、集中的接口来保持代码简单和模块化。
行为优于实现：根据行为而不是特定的实现来定义接口。

运用这些原则我们可以编写简洁、适应性强且高效的 Go 程序。

Go Learn - Interface

Outline