any/interface{} 作为约束与参数类型之间的区别？

Question

随着 Go 1.18 中最近发布了泛型，我已经开始学习它们了。我一般都明白这个概念，因为我过去有一些 Java 经验。但我没有得到一些实施细节。

例如：什么时候用

any

代替

interface{}

更合适？这是一个例子：

func printInterface(foo interface{}) {
    fmt.Printf("%v\n", foo)
}

func printAny[T any](foo T) {
    fmt.Printf("%v\n", foo)
}

func (suite *TestSuite) TestString() {
    printInterface("foo")
    printAny("foo")
}

两种实现都有效。但是，如果我尝试使用

nil

版本打印

any

，我会收到编译时错误：

无法推断 T。

https://go.dev/play/p/0gmU4rhhaOP

如果我尝试使用

nil

-版本打印

interface{}

，我不会收到此错误。

那么

any

的用例是什么？与仅使用

interface{}

相比，它何时以及会带来哪些好处？

我要求提供一个“特定”示例，其中一种实现客观上比另一种实现更合适和/或存在可以评估的“特定”好处。 除了

any

Answer 1

interface{}

是类型别名（因此在用法上等效）之外，

any

 作为类型参数

和

any

作为常规函数参数 之间存在实际差异，如您的示例中所示。

不同的是，在

printAny[T any](foo T)中，

foo

的类型不是

any

/

interface{}

，而是

T

。实例化后的

T

是一个具体类型，它本身可能是也可能不是接口。然后，您只能将参数传递给可以分配给该具体类型的实例化

printAny

。这对您的代码的影响在多个参数中最为明显。如果我们稍微改变一下函数签名：

func printInterface(foo, bar any) {
    fmt.Println(foo, bar)
}

func printAny[T any](foo, bar T) {
    fmt.Println(foo, bar)
}

实例化后：

函数

printAny

接受任意两个相同类型的参数

——以用于实例化的参数为准
• T printInterface

  ，相当于

  printInterface(foo, bar interface{})
，仍然可以接受两个不同类型的参数，因为两者都可以
• 单独

  分配给

  any

  /

  interface{}。

  printInterface(12.5, 0.1)    // ok
  printInterface(12.5, "blah") // ok, int and string individually assignable to any
  
  printAny(10, 20)             // ok, T inferred to int, 20 assignable to int
  printAny(10, "k")            // compiler error, T inferred to int, "k" not assignable to int
  printAny[any](10, "k")       // ok, T explicitly instantiated to any, int and string assignable to any
  
  printAny(nil, nil)           // compiler error, no way to infer T
  printAny[any](nil, nil)      // ok, T explicitly instantiated to any, nil assignable to any

  游乐场：
https://go.dev/play/p/pDjP986cj96

注意：在没有显式类型参数的情况下，无法使用

nil 调用泛型版本，因为 nil

本身不携带类型信息，因此编译器无法推断

T

。然而 

nil

 通常可以分配给接口类型的变量。

any

是

Answer 2

的

别名

。 

规格：接口类型： 为了方便起见，预先声明的类型any是空接口的别名。

既然是别名，那么使用哪个并不重要。它们是一体的。它们是可以互换的。您可以将其中一个替换为另一个，代码的含义是相同的。

any

更短、更清晰，但仅适用于 Go 1.18。

由于它们是可以互换的，所以这也有效：

func printInterface(foo any) {
    fmt.Printf("%v\n", foo)
}

printAny()

不起作用的原因是它是一个带有类型参数的泛型函数。要使用它，必须对其进行“实例化”（其类型参数必须指定为已知类型）。尝试使用

nil

调用它不携带任何类型信息，因此实例化无法发生，类型推断将不起作用。

如果您使用带有类型信息的 

nil 值调用它，它将起作用，或者如果您显式指定类型参数（在 Go Playground

 上尝试）：

printAny((*int)(nil))
printAny[*int](nil)
// Or
var r io.Reader
printAny(r)

如上所述，

any 与 interface{}

可以互换，因此如果交换两个出现的位置，您将获得相同的代码（在

Go Playground

上尝试这个）：

func printInterface(foo any) {
    fmt.Printf("%v\n", foo)
}

func printAny[T interface{}](foo T) {
    fmt.Printf("%v\n", foo)
}

您的问题与 any

/

interface{}

的使用无关（其差异纯粹是装饰性的），而是类型推断。正如您从

Answer 3

中看到的，如果您使用显式类型实例化函数，例如

printAny[any](nil)

，它将起作用。

如果您有一个具有泛型类型的函数，您需要指定类型。然而，go 编译器非常智能，可以为你推断一些类型。但仅靠

nil是无法推断的。

我发现这篇文章很有帮助：

https://techknowbase.com/golang-empty-interface-vs-any/

Answer 4