以值和指针方式接收接口类型的函数（Golang）

在 Golang 编程中，接口是一个非常重要的特性。接口是一种抽象类型，我们可以将它们用作通用类型来编写高度抽象的代码。但是，当我们定义接口类型的函数时，我们需要注意函数参数应该以值方式还是指针方式进行传递。这两种方式有什么区别以及如何正确选择？下文将详细讨论。

何时使用值传递

在使用接口类型的函数时，如果我们希望传递该类型的副本，则应该使用值传递方式。这种方式将保留接口值的副本并执行任何修改。例如：

package main

import "fmt"

type employee interface {
    getID() int
    getName() string
    getSalary() float32
}

type fullTimeEmployee struct {
    id     int
    name   string
    salary float32
}

func (ftEmployee fullTimeEmployee) getID() int {
    return ftEmployee.id
}

func (ftEmployee fullTimeEmployee) getName() string {
    return ftEmployee.name
}

func (ftEmployee fullTimeEmployee) getSalary() float32 {
    return ftEmployee.salary
}

func raiseSalary(e employee) {
    ftEmployee := e.(fullTimeEmployee)
    ftEmployee.salary = ftEmployee.salary * 1.10
    fmt.Printf("The salary of employee %d (%s) is now %0.2f", ftEmployee.id, ftEmployee.name, ftEmployee.salary)
}

func main() {
    ftEmployee := fullTimeEmployee{
        id:     1,
        name:   "John Doe",
        salary: 50000,
    }
    fmt.Printf("Old salary of employee %d (%s):%0.2f\n", ftEmployee.id, ftEmployee.name, ftEmployee.salary)
    raiseSalary(ftEmployee)
    fmt.Printf("New salary of employee %d (%s): $%0.2f\n", ftEmployee.id, ftEmployee.name, ftEmployee.salary)
}

在上述示例中，我们定义了一个 employee 接口和一个结构类型 fullTimeEmployee，该类型实现了 employee 接口中的所有方法。在 raiseSalary() 函数中，我们将接口值转换为 fullTimeEmployee 类型，并将其薪资增加 10%。注意，在函数内部修改了实参副本的薪资。

输出：

Old salary of employee 1 (John Doe): 50000.00
The salary of employee 1 (John Doe) is now55000.00New salary of employee 1 (John Doe): $50000.00

如上所示，当我们传递一个 fullTimeEmployee 类型值时，输出的结果不会发生任何变化，因为此变量没有被修改。如果我们的编写这个函数的目的是更改传递给函数的副本，我们应该使用值传递方式，以确保副本的修改不会影响原始实例。

值传递方式还确保了传递给函数的接口值的副本具有与原始实例在内存中不同的地址。因此，当我们在后续代码中使用该值进行比较时，将可以区分原始实例和其副本。

何时使用指针传递

当我们使用指针类型传递接口值时，我们传递的是实例的引用（或指针），而不是该值的副本。这意味着在函数中执行的任何修改都将直接反映在传递给函数的原始实例上。

考虑以下示例代码：

package main

import "fmt"

type employee interface {
    getID() int
    getName() string
    getSalary() float32
    changeName(string)
}

type fullTimeEmployee struct {
    id     int
    name   string
    salary float32
}

func (ftEmployee *fullTimeEmployee) getID() int {
    return ftEmployee.id
}

func (ftEmployee *fullTimeEmployee) getName()string {
    return ftEmployee.name
}

func (ftEmployee *fullTimeEmployee) getSalary() float32 {
    return ftEmployee.salary
}

func (ftEmployee *fullTimeEmployee) changeName(newName string) {
    ftEmployee.name = newName
    fmt.Printf("Employee %d's name has been changed to %s.\n", ftEmployee.id, ftEmployee.name)
}

func main() {
    ftEmployee := fullTimeEmployee{
        id:     1,
        name:   "John Doe",
        salary: 50000,
    }
    fmt.Printf("Old name of employee %d: %s\n", ftEmployee.id, ftEmployee.name)
    ftEmployee.changeName("Jane Doe")
    fmt.Printf("New name of employee %d: %s\n", ftEmployee.id, ftEmployee.name)
}

在上述代码中，我们定义了 employee 接口和 fullTimeEmployee 结构类型，它们实现了接口中的所有方法。在 changeName() 函数中，我们更改了传递给函数的 fullTimeEmployee 实例的姓名。

值得注意的是，我们将 getID(), getName(), 和 getSalary() 方法定义为 *fullTimeEmployee 指针类型的接收者，这意味着只能通过指针调用这些方法。在 changeName() 方法中，我们也将接收者定义为指针类型，以便在函数中进行更改，如前所述。

输出：

Old name of employee 1: John Doe
Employee 1's name has been changed to Jane Doe.
New name of employee 1: Jane Doe

如上所示，当我们传递一个 fullTimeEmployee 实例时，函数中的更改将直接反映在原始实例上。

此外，通过使用指针传递方式，我们还可以在内存中共享数据。这意味着我们可以通过传递指向实例的指针，让多个函数对相同的数据进行修改。这对于在程序中管理大型数据结构非常有用。

如何选择正确的方式

要正确选择参数传递方式，我们需要根据函数的目的向参数传递原始数据还是其副本。

如果我们希望在函数内部修改传递给参数的实例数据，则应该使用指针方式；如果我们不希望更改原始实例数据，而是对该数据的副本进行修改，则应该使用值方式。

可以根据下面的准则来决定是使用值还是指针：

• 如果方法需要修改接收者的内容或状态，则应该使用指针。
• 如果这个方法只是返回接收者的某个属性，则可以使用值或指针。
• 如果接收者是容器，例如数组或结构体，则应该使用指针来避免传递整个容器。
• 如果接收者是小型的不可变的值或结构体，则可以使用值，以便进行更好的内联。

总的来说，使用值方式可以保持安全，因为它可以防止代码意外修改接收者的状态。然而，使用指针可以更有效地处理大型数据结构。

结论

在 Golang 编程中，我们可以选择使用值方式或指针方式来接收接口类型的函数参数。正确的选择将取决于我们想要达到的目标和接收者的类型。我们应该评估函数的目的，并选择适当的方法传递参数。这有助于编写更有效和可维护的代码。