Go基础篇:接口

本文最后更新于:4 个月前

前言✨

前段时间忙着春招面试,现在也算告一段落,找到一家比较心仪的公司实习,开始慢慢回归状态,这后面几章我会学习go1.19版本的语言特性或者机制:类型系统、接口、断言以及反射的内容,也算是补上之前没有深入底层的内容。

一、什么是接口?

Go语言中的接口(interface)是一种类型,它定义了一组方法的集合,但没有具体的实现。接口可以被任何类型实现,只要该类型实现了接口中定义的所有方法。这种设计方式使得Go语言具有很高的灵活性和可扩展性。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
// 定义一个接口,包含一个String方法
type Stringer interface {
String() string
}

// 定义一个结构体,实现Stringer接口
type Person struct {
Name string
Age int
}

func (p Person) String() string {
return fmt.Sprintf("%s (%d)", p.Name, p.Age)
}

func TestInterface(t *testing.T) {
// 定义一个接口变量,只能存储实现了Stringer接口的值
var str Stringer
// str = 42 // 编译错误,int类型没有实现Stringer接口
// str = "hello" // 编译错误,string类型没有实现Stringer接口
str = Person{"Bob", 30}
fmt.Println(str) // Bob (30)
}

Go语言接口的特点是:

  • 接口是一种抽象的类型,它只定义了一组方法,而不指定具体的实现。
  • 接口是隐式实现的,也就是说,任何类型只要实现了接口的所有方法,就可以被认为是该接口的实例,而不需要显式地声明。
  • 接口可以组合,也就是说,一个接口可以包含另一个接口的所有方法,一个接口可以由多个接口的方法组成,从而实现接口的多态。

Go语言接口的优点是:

  • 接口可以提高代码的复用性和可维护性,因为它可以将不同类型的对象抽象为统一的接口,从而降低了代码之间的耦合度。
  • 接口可以提高代码的灵活性和扩展性,因为它可以支持多种实现方式,从而增加了代码的可变性和可选择性。
  • 接口可以提高代码的测试性和可测性,因为它可以方便地使用模拟对象或桩对象来替代真实对象,从而简化了单元测试和集成测试。

二、空接口 interface{}

Go语言中的接口是一种类型,它定义了一组方法的集合,接口可以分为空接口和非空接口。空接口(interface{})是一种特殊的接口类型,它没有任何方法,因此可以表示任何类型的值。非空接口则是指至少有一个方法的接口类型。

Jordan Oreilli 对空接口的一个很好的定义:

接口是两件事物:它是一组方法,但它也是一种类型。
空接口 interface{} 类型是没有方法的接口。由于 Go 语言没有 implements 关键字,所有类型都至少实现零个方法,并且接口是隐式实现的,所有类型都满足空接口。

1、eface的定义

在 Go 的泛型未敲定前,空接口和断言广泛用于实现泛型,空接口的底层数据结构是 eface,它是一个结构体,包含两个字段:_type和data。

eface结构体定义如下:

1
2
3
4
type eface struct {
_type *_type
data unsafe.Pointer
}

其中,_type是一个指向类型信息的指针,它包含了类型的名称、大小、对齐方式等信息。(不了解的请看上一节篇《Go基础篇:类型系统》),data是一个指向实际值的指针,它可以存储任何类型的值。

举个简单的例子:

1
2
3
4
5
6
7
8
9
10
11
12
13
type MyString string

// 输出val的值和类型,这里只是稍微用到了反射reflect的TypeOf方法获取类型,后面我会详细讲的
func Print(val interface{}) {
fmt.Println(val, reflect.TypeOf(val))
}

func TestPrint(t *testing.T) {
name := "linzy1"
Print(name)
var Myname MyString = "linzy2"
Print(Myname)
}

例子中在空接口被赋值string类型和自定义类型时的值虽然相同,但是类型却不同,且都不是空接口 interface{} 类型。这是为什么呢?

当我们使用空接口来存储一个值时,Go语言会将该值的类型信息和实际值分别存储在eface结构体的_type和data字段中。在需要使用该值时,Go语言会根据_type字段中的类型信息,将data字段中的值转换为相应的类型,并进行相应的操作。

具体来说,当一个空接口变量被赋值为string类型的值时,Go语言会将该值的类型描述信息存储在该变量的_type字段中。这个类型描述信息包含了string类型的名称、大小、对齐方式等信息,可以通过反射包中的TypeOf()函数获取。

需要注意的是,由于空接口可以存储任何类型的值,因此在使用空接口时需要进行类型断言或类型转换,以确保程序的正确性。

2、需要注意的问题

空接口可以存储任何类型的值,但是 []interface{} 空接口切片类型不一样,[]interface{} 可以存储任何类型的值,但是不能直接赋值切片或者切片转换。

举个简单的例子:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
func PrintAll(vals []interface{}) {
fmt.Println("vals Type is:", reflect.TypeOf(vals))
for _, val := range vals {
fmt.Println(val, reflect.TypeOf(val))
}
}

func TestPrint(t *testing.T) {
names := []string{"stanley", "david", "oscar"}
// ./interface_test.go:144:11: cannot use names (variable of type []string) as type []interface{} in argument to PrintAll
// PrintAll(names)
ns := make([]interface{}, len(names))
for i, name := range names {
ns[i] = name
}
PrintAll(ns)

ns = []interface{}{"linzy", 32, 1.68}
PrintAll(ns)
}

在Go语言中,[]interface{}和[]string是两种不同的类型,它们之间不能直接赋值或转换。虽然[]interface{}可以存储任何类型的值,包括string类型,但是它本身并不是string类型的切片,因此不能直接赋值给[]string类型的变量。

最核心的点在于 slicetype 中的 elem 类型描述不同,所以他们是两种不同的类型。

1
2
3
4
type slicetype struct {
typ _type
elem *_type
}

三、非空接口

非空接口是指具有实际类型的接口,想要赋值给非空接口类型必须要实现该接口的所有方法,也就是说,它不是空接口。

1、iface的定义

在Go语言中,非空接口的底层数据结构是iface,它是一个结构体,定义如下:

1
2
3
4
type iface struct {
tab *itab
data unsafe.Pointer
}

其中,tab是一个指向方法表的指针,data是一个指向实际对象的指针。

2、itab的定义

itab是一个结构体,它定义了接口类型和实现类型之间的关系,包括接口类型的方法集合、实现类型的方法集合和方法表等信息。itab的定义如下:

1
2
3
4
5
6
7
type itab struct {
inter *interfacetype
_type *_type
hash uint32
_ [4]byte
fun [1]uintptr
}

其中,inter是一个指向接口类型的指针,_type是一个指向动态类型的指针,hash是实现类型的哈希值,fun是一个指向方法表的指针数组,指向的是动态类型实现接口方法的地址

interfacetype和_type都是类型对象,它们包含了类型的名称、大小、对齐方式、方法集合等信息。uintptr是一个无符号整数类型,它可以存储指针类型的值。

itab结构体的大小是可变的,因为它的最后一个字段fun是一个指针数组,它的长度取决于实现类型的方法集合的大小。当实现类型的方法集合发生变化时,Go语言会重新生成一个新的itab结构体,并将其添加到缓存中以便后续可以复用。

举个简单的例子:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
func TestReadWriter(t *testing.T) {
// 定义io.ReadWriter接口类型的变量rw,需要实现Read和Write两个方法
var rw io.ReadWriter
f, _ := os.Open("linzy.txt")
defer f.Close()
rw = f

// os.Stat函数获取文件的大小
Stat, _ := f.Stat()

tmp := make([]byte, Stat.Size())
rw.Read(tmp)
fmt.Println(string(tmp))
}

rw 赋值后
赋值的变化过程:

  • 当你将f \*os.File类型变量赋值给rw变量时,Go语言会生成一个新的itab结构体。它的inter字段指向io.ReadWriter接口类型的描述信息,_type字段指向*os.File类型的描述信息,fun字段指向一个方法表,其中包含了io.ReadWriter接口类型的需要的所有方法,拷贝的是方法地址。
  • Go语言会使用一个全局的哈希表来缓存itab结构体,这个itab结构体会被缓存起来以便后续可以复用。
  • 当你调用rw.Read(tmp)方法时,Go语言会根据rw变量对应的itab指针找到对应的方法表,并调用其中的Read方法。

总结:
当你将一个实现了接口类型的值赋给接口类型的变量时,Go语言会根据实际对象的类型和接口类型的方法集合生成一个新的itab结构体,并将其赋值给接口类型变量对应的itab指针。
这个itab结构体包含了接口类型的方法集合、实现类型的方法集合和方法表等信息,通过这些信息可以实现接口方法的调用。

3、itab缓存

一个非空接口类型和一个动态类型就可以确定一个itab的内容,容易出现重复的itab结构体。Go为了避免重复生成itab结构体的开销,并且可以减少内存的使用,提高程序的性能。
itab可复用

Go语言会使用一个全局的哈希表来缓存itab结构体,这个哈希表的键是一个由<接口类型, 动态类型>组成的key,值是对应的*itab结构体的指针。当我们创建一个非空接口变量时,Go语言会先在缓存中查找对应的itab结构体,如果找到了就直接使用,否则就动态生成一个新的itab结构体,并将其添加到缓存中以便后续可以复用。


但是这里说的哈希表跟go的map哈希表不相同,itab设计的哈希表结构更简单:

1
2
3
4
5
type itabTableType struct {
size uintptr // length of entries array. Always a power of 2.
count uintptr // current number of filled entries.
entries [itabInitSize]*itab // really [size] large
}

需要一个itab时,会首先去itabTable里查找,计算哈希值时会用到接口类型(itab.inter)和动态类型(itab._type)的类型:

1
2
3
4
func itabHashFunc(inter *interfacetype, typ *_type) uintptr {
// compiler has provided some good hash codes for us.
return uintptr(inter.typ.hash ^ typ.hash)
}

如果能查询到对应的itab指针,就直接拿来使用。若没有就要再创建,然后添加到itabTable中。


Go基础篇:接口
https://gopherlinzy.github.io/2023/05/17/go-interface/
作者
孙禄毅
发布于
2023年5月17日
许可协议