Go语言type关键字（类型别名）

前言

在讨论type关键字之前，先了解一下type关键字的意义。类型别名是 Go 1.9 版本添加的新功能，主要用于解决代码升级、迁移中存在的类型兼容性问题。Go语言难免和C/C++进行比较，在 C/C++ 语言中，代码重构升级可以使用宏快速定义一段新的代码，Go语言中没有选择加入宏，而是解决了重构中最麻烦的类型名变更问题。由于工作之后没有进行过任何C语言编程开发，这里不做详细讨论，主要是为了说明类型别名对于Go语言的意义。

在 Go 1.9 版本之前定义内建类型的代码是这样写的：

type byte uint8
type rune int32

为了配合类型别名，1.9版本之后修改如下：

type byte = uint8
type rune = int32

这里主要是区分了类型别名和类型的定义，虽然只是一个等号的差别，但是指代的是不同的操作。形如：type TypeAlias = Type 的是类型的别名。类型别名规定：TypeAlias 只是 Type 的别名，本质上 TypeAlias 与 Type 是同一个类型。

区分类型别名与类型定义

直接看代码：

package main

import (
    "fmt"
)

// 将NewInt定义为int类型
type NewInt int

// 将int取一个别名叫IntAlias
type IntAlias = int

func main() {

    // 将a声明为NewInt类型
    var a NewInt
    // 查看a的类型名
    fmt.Printf("a type: %T\n", a)

    // 将a2声明为IntAlias类型
    var a2 IntAlias
    // 查看a2的类型名
    fmt.Printf("a2 type: %T\n", a2)
}

运行结果：

a type: main.NewInt
a2 type: int

• 第 8 行，将 NewInt 定义为 int 类型，这是常见的定义类型的方法，通过 type 关键字的定义，NewInt 会形成一种新的类型，NewInt 本身依然具备 int 类型的特性。
• 第 11 行，将 IntAlias 设置为 int 的一个别名，使用 IntAlias 与 int 等效。
• 第 16 行，将 a 声明为 NewInt 类型，此时若打印，则 a 的值为 0。
• 第 18 行，使用%T格式化参数，打印变量 a 本身的类型。
• 第 21 行，将 a2 声明为 IntAlias 类型，此时打印 a2 的值为 0。
• 第 23 行，打印 a2 变量的类型

由结果可以说明：

 a 的类型是 main.NewInt，表示 main 包下定义的 NewInt 类型，a2 类型是 int，IntAlias 类型只会在代码中存在，编译完成时，不会有 IntAlias 类型（由于在Go语言的编译过程中，编译器会对代码进行优化，产生中间代码，类型别名回被解释为实质上的类型，所以编译完成不会存在类型别名）。

非本地类型不能定义方法

由于类型别名的存在，会让人不由自主的想到，能否在自己的包里为这些类型任意的添加方法呢？

package main

import (
    "time"
)

// 定义time.Duration的别名为MyDuration
type MyDuration = time.Duration

// 为MyDuration添加一个函数
func (m MyDuration) EasySet(a string) {

}

func main() {

}

当编译这段Go的源码时，会报错：

cannot define new methods on non-local type time.Duration

不能在一个非本地的类型 time.Duration 上定义新方法，非本地类型指的就是 time.Duration 不是在 main 包（该编译文件所在包）中定义的，而是在 time 包中定义的，与 main 包不在同一个包中，因此不能为不在一个包中的类型定义方法。包是Go语言管理代码的重要机制，其作用类似于Java中的 package 和 C/C++ 的头文件。Go 源文件中第一段有效代码必须是package <包名> 的形式，如 package hello。

那能不能解决这个问题呢？那必须的啊！

1.根据错误信息，很明显，第一个想到的就是把MyDuration的定义放在time包（QaQ为什么不是把Duration类型写在main包，那不是废话嘛，内置的类型）

2.把MyDuration定义为类型，而不是类型别名，上面介绍类型定义和类型别名区别的时候，其实已经很明显了，打印NewInt类型的时候，输出的是 main.NewInt，很明显可以看出，这是一个在当前包中的一个类型定义，完美解决了编译报错说明的问题。

在结构体成员嵌入时使用别名

直接上代码，看一下就好了，没有什么要讨论的（目前没有）

package main

import (
    "fmt"
    "reflect"
)

// 定义商标结构
type Brand struct {
}

// 为商标结构添加Show()方法
func (t Brand) Show() {
}

// 为Brand定义一个别名FakeBrand
type FakeBrand = Brand

// 定义车辆结构
type Vehicle struct {

    // 嵌入两个结构
    FakeBrand
    Brand
}

func main() {

    // 声明变量a为车辆类型
    var a Vehicle
   
    // 指定调用FakeBrand的Show
    a.FakeBrand.Show()

    // 取a的类型反射对象
    ta := reflect.TypeOf(a)
    // 遍历a的所有成员

    for i := 0; i < ta.NumField(); i++ {

        // a的成员信息
        f := ta.Field(i)

        // 打印成员的字段名和类型
        fmt.Printf("FieldName: %v, FieldType: %v\n", f.Name, f.Type.
            Name())
    }
}

go run后输出如下：

FieldName: FakeBrand, FieldType: Brand
FieldName: Brand, FieldType: Brand

• 第 9 行，定义商标结构。
• 第 13 行，为商标结构添加 Show() 方法。
• 第 17 行，为 Brand 定义一个别名 FakeBrand。
• 第 20～25 行，定义车辆结构 Vehicle，嵌入 FakeBrand 和 Brand 结构。
• 第 30 行，将 Vechicle 实例化为 a。
• 第 33 行，显式调用 Vehicle 中 FakeBrand 的 Show() 方法。
• 第 36 行，使用反射取变量 a 的反射类型对象，以查看其成员类型。
• 第 39～42 行，遍历 a 的结构体成员。
• 第 45 行，打印 Vehicle 类型所有成员的信息。

将第 33 行改为：a.Show()

编译器将发生报错：ambiguous selector a.Show

原因：在调用 Show() 方法时，因为两个类型都有 Show() 方法，会发生歧义，证明 FakeBrand 的本质确实是 Brand 类型，印证了第一次输出的类型都是Brand类型的结果。