interface{} 的含义是什么? [英] What's the meaning of interface{}?

问题描述

我是接口的新手，并尝试通过 似乎指出了any作为 Go 1.18(2022 年第一季度)中 interface{} 的别名

Russ Cox 解释:

<块引用>

1. 'any' 仅用于约束是泛型的每一篇文章中都会出现的一个细节——书籍、博客文章等等.如果我们认为我们最终可能会允许它，那么从一开始就允许它并避免使所有书面材料无效是有意义的.

2. 'any' 仅用于约束是一种意外的删减，它降低了概念的通用性和正交性.说让我们拭目以待"很容易，但处方用途往往会产生比完全通用性更多的参差不齐的特征.我们也通过类型别名看到了这一点(谢天谢地，我们抵制了几乎所有提议的删减).

3. 如果泛型中允许使用any"而不是非泛型代码，那么它可能会鼓励人们过度使用泛型，因为any"更好编写比 'interface{}' 时，真正应该考虑其他因素来决定是否使用泛型.

4. 如果我们也允许 'any' 用于普通的非泛型用法，那么在代码中看到 interface{} 可以作为一种信号，表明代码早于泛型并且在后泛型世界中尚未被重新考虑.一些使用 interface{} 的代码应该使用泛型.其他代码应该继续使用接口.
   以一种或另一种方式重写它以删除文本interface{}"将使人们清楚地了解他们更新了什么和没有更新什么.(当然，出于向后兼容性的原因，一些可能更适合泛型的代码仍必须使用 interface{}，但仍可以更新它以确认已考虑并做出决定.)>

该线程还包括关于接口{}的说明:

<块引用>

这不是一个特殊的设计，而是 Go 的类型声明语法的逻辑结果.

您可以使用具有多个方法的匿名接口:

func f(a interface{Foo(); Bar()}) {a.Foo()一间酒吧()}

类似于如何在需要类型的任何地方使用匿名结构:

func f(a struct{Foo int; Bar string}) {fmt.Println(a.Foo)fmt.Println(a.Bar)}

一个空接口恰好匹配所有类型，因为所有类型至少有零个方法.

如果您想保持一致/不想引入特殊情况，那么删除 interface{} 意味着从语言中删除所有界面功能.

I'm new to interfaces and trying to do SOAP request by github

I don't understand the meaning of

Msg interface{}

in this code:

type Envelope struct {
    Body `xml:"soap:"`
}

type Body struct {
    Msg interface{}
}

I've observed the same syntax in

fmt.Println

but don't understand what's being achieved by

interface{}

解决方案

You can refer to the article "How to use interfaces in Go" (based on "Russ Cox’s description of interfaces"):

What is an interface?

An interface is two things:

• it is a set of methods,
• but it is also a type

The interface{} type, the empty interface is the interface that has no methods.

Since there is no implements keyword, all types implement at least zero methods, and satisfying an interface is done automatically, all types satisfy the empty interface.
That means that if you write a function that takes an interface{} value as a parameter, you can supply that function with any value.

(That is what Msg represents in your question: any value)

func DoSomething(v interface{}) {
   // ...
}

Here’s where it gets confusing:

inside of the DoSomething function, what is v's type?

Beginner gophers are led to believe that "v is of any type", but that is wrong.
v is not of any type; it is of interface{} type.

When passing a value into the DoSomething function, the Go runtime will perform a type conversion (if necessary), and convert the value to an interface{} value.
All values have exactly one type at runtime, and v's one static type is interface{}.

An interface value is constructed of two words of data:

• one word is used to point to a method table for the value’s underlying type,
• and the other word is used to point to the actual data being held by that value.

---

Addendum: This is were Russ's article is quite complete regarding an interface structure:

type Stringer interface {
    String() string
}

Interface values are represented as a two-word pair giving a pointer to information about the type stored in the interface and a pointer to the associated data.
Assigning b to an interface value of type Stringer sets both words of the interface value.

The first word in the interface value points at what I call an interface table or itable (pronounced i-table; in the runtime sources, the C implementation name is Itab).
The itable begins with some metadata about the types involved and then becomes a list of function pointers.
Note that the itable corresponds to the interface type, not the dynamic type.
In terms of our example, the itable for Stringer holding type Binary lists the methods used to satisfy Stringer, which is just String: Binary's other methods (Get) make no appearance in the itable.

The second word in the interface value points at the actual data, in this case a copy of b.
The assignment var s Stringer = b makes a copy of b rather than point at b for the same reason that var c uint64 = b makes a copy: if b later changes, s and c are supposed to have the original value, not the new one.
Values stored in interfaces might be arbitrarily large, but only one word is dedicated to holding the value in the interface structure, so the assignment allocates a chunk of memory on the heap and records the pointer in the one-word slot.

---

Issue 33232 seems to point out to any as an alias to interface{} in Go 1.18 (Q1 2022)

Russ Cox explains:

1. 'any' being only for constraints is a detail that will be in every writeup of generics - books, blog posts, and so on. If we think we are likely to allow it eventually, it makes sense to allow it from the start and avoid invalidating all that written material.

2. 'any' being only for constraints is an unexpected cut-out that reduces generality and orthogonality of concepts. It's easy to say "let's just wait and see", but prescribing uses tends to create much more jagged features than full generality. We saw this with type aliases as well (and resisted almost all the proposed cut-outs, thankfully).

3. If 'any' is allowed in generics but not non-generic code, then it might encourage people to overuse generics simply because 'any' is nicer to write than 'interface{}', when the decision about generics or not should really be made by considering other factors.

4. If we allow 'any' for ordinary non-generic usage too, then seeing interface{} in code could serve as a kind of signal that the code predates generics and has not yet been reconsidered in the post-generics world. Some code using interface{} should use generics. Other code should continue to use interfaces.
   Rewriting it one way or another to remove the text 'interface{}' would give people a clear way to see what they'd updated and hadn't. (Of course, some code that might be better with generics must still use interface{} for backwards-compatibility reasons, but it can still be updated to confirm that the decision was considered and made.)

That thread also includes an explanation about interface{}:

It's not a special design, but a logical consequence of Go's type declaration syntax.

You can use anonymous interfaces with more than zero methods:

func f(a interface{Foo(); Bar()}) {
   a.Foo()
   a.Bar()
}

Analogous to how you can use anonymous structs anywhere a type is expected:

func f(a struct{Foo int; Bar string}) {
   fmt.Println(a.Foo)
   fmt.Println(a.Bar)
}

An empty interface just happens to match all types because all types have at least zero methods.

Removing interface{} would mean removing all interface functionality from the language if you want to stay consistent / don't want to introduce a special case.

这篇关于interface{} 的含义是什么?的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！