理解 Go 类型系统

发表于 | 分类于

Type 的分类

在 Go 中所有需要被定义和声明的对象都是 Type:

  • int
  • string
  • function
  • pointer
  • interface
  • map
  • struct
  • chan
  • …

和大多数计算机语言一样，Go Type 默认包含常用的基础数据类型，称为 Pre-declarered types 比如:

  • boolean
  • numeric
  • string

基础数据类型又可以进一步构成更复杂的类型，称之为 Composite Types 比如:

  • array
  • struct
  • map
  • slice
  • channel
  • func
  • interface
  • …

Composite Types 由 Pre-declared Types 组成的复杂数据类型，其形式常常是 Type Literal ，比如 array 的字面量声明 var array [10]int ，map 的字面量 var dict map[int]string。

Type 可以分为带名称和不带名称的，前者称之为 Named Type，后者称之为 Unnamed Type。

Named Types 就是通过 type 关键字为一个已有的 type 起个别名，像这样 type NewType ExistingType NewType 就是别名。Pre-declared types 也是 Named Types，也可以为 Pre-Declared Types 起个别名: type Integer int.

Unamed Types 是一个 Literal Type，也就是没有名字只有 type 本身，像这样 [6]int 、map[string]int。

每一个类型都有自己的 Underlying Type ，如果 T 是 Pre-declared type 或者 Type Literal，它们对应的 Underlying Type 就是自身 T，否则 T 的 Underlying Type 是 T 定义时引用的类型的 Underlying Type，比如 type T int 的 Underlying Type 是 int，int 是 Pre-declared；type T map[int]string 的 Underlying Type 是 map[int]string，map[int]string 是 Type Literal。

Underlying type

如果两个 type 的 Underlying Type 相同，则它们可以有以下特性。

1.如果两个 type 都是 named type ，彼此之间不能相互赋值

1
2
3
type NewString string
var my string ="a"
var you NewString = my //cannot use my (type string) as type NewString in assignment

虽然它们的 Underlying Type 都是 string，但 string 类型的 my 不能赋值给 NewString 类型的 you。

2.如果两个 type 其中一个是 Unnamed Type，彼此之间可以相互赋值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package main

type Ptr *int
//named type
type Map map[int]string
type MapMap Map

func main() {
    var p *int
    var mm Map
    var mmm MapMap
    //m1 m2 是 Unnamed Type
    var m1 map[int]string = mm
    var m2 map[int]string = mmm
    var ptr Ptr = p
    print(ptr)
    print(m1)
    print(m2)
}

为什么 type 之间会有这样的差别?

如果为一个类型起了名字，说明你想要做区分，所以两个 named types 即使 Underlying Type 相同也是不能相互赋值的。

详见Google Group Topic

Named type 和 Unamed type

当 named types 被作为一个 function 的 receiver 时，它就拥有了自己的方法，unamed types 则不能，这是它们的重要区别。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package main

import (
    "fmt"
)

type NewMap map[int]string

func (nm NewMap) add(key int, value string) {
    nm[key] = value
}

func main() {
    var p NewMap = make(map[int]string)
    p.add(10, "a")
    fmt.Println(p) //map[10:a]
}

有个一例外是 Pre-Declared Types 不能拥有自己的方法。

1
2
3
4
5
6
7
8
9
10
11
package main


func (n int) name(){   
    print(n)
}

func main() {
    var n int
    n.name()
}

编译器会抛出 cannot define new methods on non-local type int 错误，不能对包之外的 type 定义方法，解决这个问题就是对 pre-declared types 重新定义别名。

type 的属性继承

直接继承

已经声明的 Named Type 不会从它的 Underlying Type 或 existing type 继承 method，但是会继承 field。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
package main

import (
    "fmt"
)

type Person struct {
    name string
}

func (p *Person) Speak() {
    fmt.Println("I am a person")
}

//Student 是 Named Type
type Student Person

func main() {
    var p Person
    p.Speak()
    var s Student
    s.name = "jone"
    fmt.Println(s.name)
    // s.Speak()
}

Named Type Student 不会继承来自 Person 的 Speak 的方法，打开注释执行报错 s.Speak undefined (type Student has no field or method Speak)，但是 Student 可以继承 Person 的 filed: s.name 可以使用。

The declared type does not inherit any methods bound to the existing type, but the method set of an interface type or of elements of a composite type remains unchanged:

但是也有例外的情况。

如果 existing type 是 interface，它的 method set 会被继承。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
package main

import (
    "fmt"
)

type I interface {
    Talk()
}

// existing type 是 I，I 是个接口，可以直接继承 I 的方法，II 等同于 I
type II I

type Person struct {
    name string
}

func (p *Person) Speak() {
    fmt.Println("I am a person")
}

func (p *Person) Talk() {
    fmt.Println("I am talking")
}

func main() {
    var p Person
    p.Speak()
    p.Talk()
    var i I
    i = &p
    i.Talk()
    var ii II
    ii = &p
    ii.Talk()
}

II 继承了 I 的 method，所以 Person 也实现了 II。

如果 existing type 被嵌入新 type 作为 filed

如果一个 type TB 被嵌入另一个 type T 作为它的 filed，TB 的所有 field 和 method 都可以在 T 中使用，这种方法称之为 type embedding。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
package main

import (
    "fmt"
)

type I interface {
    Talk()
}

type Person struct {
    name string
}

func (p *Person) Speak() {
    fmt.Println("I am a person")
}

func (p *Person) Talk() {
    fmt.Println("I am talking")
}

type People struct {
    Person
}

func main(){
    var people People
    people.name = "people"
    people.Speak()
    people.Talk()
}

type 转换

Type 之间是可以相互转换的，但要遵循一定的转换规则，详细请看官方规范 https://golang.org/ref/spec#Conversions。

参考代码

文中部分代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
package main

import (
    "fmt"
)

type I interface {
    Talk()
}

type Person struct {
    name string
}

func (p *Person) Speak() {
    fmt.Println("I am a person")
}

func (p *Person) Talk() {
    fmt.Println("I am talking")
}

type Student Person

type HighStudent Student

type People struct {
    Person
}

func main() {
    var p Person
    p.Speak()
    p.Talk()
    var s Student
    s.name = "jone"
    fmt.Println(s.name)
    var hs HighStudent
    hs.name = "High jone"
    fmt.Println(hs.name)
    var i I
    i = &p
    i.Talk()
    var people People
    people.name = "people"
    people.Speak()
    people.Talk()
    // s.Speak()
}

参考资料

三月沙 wechat
扫描关注 wecatch 的公众号