在 Go 语言中,type 关键字不仅可以用来定义结构体,还可以基于已有的数据类型(如 int、string 等)定义出新的类型名称。
根据中间是否带有等号(=),这种用法主要有 2 种:① 自定义类型(不带等号);② 类型别名(带等号)。这两种写法表面上看只差一个等号,但在语法规则上有着本质区别。
Go 自定义类型
在 Go 语言中,当我们使用 type 关键字且中间不加等号(=)时,就表示定义一个 “自定义类型”。自定义类型相当于 “另立门户”,它会创建出一个全新的、独立的数据类型。
语法:
type 新类型名 原类型说明:
即使新类型底层依赖的是原类型(如 type MyInt int),MyInt 和 int 依然属于两个完全不同的数据类型。
两个同为 MyInt 类型的变量之间可以直接相加。但 MyInt 变量与普通的 int 变量之间既不能直接赋值,也不能直接混合运算,我们必须先进行显式的类型转换才行。
示例 1:定义自定义类型
package main
import "fmt"
// 定义自定义类型
type MyInt int
func main() {
var a MyInt = 10
var b int = 20
// 打印两个变量的具体类型
fmt.Printf("a 的类型:%T,b 的类型:%T\n", a, b)
// 显式转换为相同类型后再相加
sum := int(a) + b
fmt.Println(sum)
}运行结果如下。
a 的类型:main.MyInt,b 的类型:int
30分析:
type MyInt int 表示定义了一个名为 MyInt 的自定义类型。从 %T 的输出结果可以看出,变量 a 的类型是 main.MyInt,而变量 b 的类型是 int,两者属于不同的数据类型。
由于不同类型的数据不能直接混合运算,我们需要先通过 int(a) 将 a 转换为 int 类型,然后再与 b 相加。如果省去类型转换直接相加,编译时就会报错:
sum := a + b // 不同类型不能直接相加上面这行代码会触发编译报错 invalid operation: a + b (mismatched types MyInt and int),提示 MyInt 和 int 类型不匹配。
既然底层存的都是整数,平时为什么要专门定义新类型呢?其实在实际开发中,我们可以定义 type UserID int 和 type OrderID int 来分别表示用户编号和订单编号。
这样一来,哪怕调用函数时不小心把用户编号传给了接收订单编号的参数,编译器也会立即报错,帮我们避免不同业务编号混用。
除了做严格的类型区分之外,自定义类型还有一个非常实用的本领:为基本类型绑定方法。前面我们学过,Go 不允许直接给内置基本类型绑定方法。但只要先使用 type 将它包装成当前包下的自定义类型,就能像结构体那样绑定专属方法了。请看下面例子。
示例 2:为自定义类型绑定方法
package main
import "fmt"
type MyInt int
// 为 MyInt 绑定方法
func (m MyInt) IsPositive() bool {
return m > 0
}
func main() {
var num1 MyInt = 15
var num2 MyInt = -5
fmt.Println(num1.IsPositive())
fmt.Println(num2.IsPositive())
}运行结果如下。
true
false分析:
func (m MyInt) IsPositive() bool 表示将 IsPositive() 方法绑定到了自定义的 MyInt 类型上。这样一来,任何 MyInt 类型的变量都可以直接调用 .IsPositive() 来判断自身是否为正数。
提示: 这种用法在 Go 标准库中非常常见。比如后面学习日期时间会用到的 time.Duration(时间间隔),底层其实就是通过 type Duration int64 定义的自定义类型,标准库专门为它绑定了换算秒数、毫秒数等实用方法。
Go 类型别名
如果在使用 type 定义类型时,在新名字和原类型之间加上一个等号(=),定义出来的就不是新类型,而是 “类型别名(type alias)”。其中,“alias” 是 “别名、外号” 的意思。
类型别名并没有创建出新的数据类型,只是给原来的类型多起了一个 “小名”。就像 “鲁迅” 和 “周树人” 指的是同一个人一样,类型别名和原类型在 Go 语言中是完全等价的。

语法:
type 别名 = 原类型说明:
由于类型别名和原类型代表的是同一个类型,它们之间可以直接赋值、直接混合运算,不需要做任何类型转换。当我们使用 %T 打印类型别名变量时,显示的也是底层的原类型名称。
示例 3:定义类型别名
package main
import "fmt"
// 定义类型别名
type IntAlias = int
func main() {
var x IntAlias = 10
var y int = 20
// 打印两个变量的具体类型
fmt.Printf("x 的类型:%T,y 的类型:%T\n", x, y)
// 直接相加无需转换
res := x + y
fmt.Println(res)
}运行结果如下。
x 的类型:int,y 的类型:int
30分析:
type IntAlias = int 中间带有等号 =,表示给 int 起了一个别名叫 IntAlias。在编译阶段,编译器会直接把 IntAlias 当成 int 处理,因此打印 x 的类型输出依然是 int,小伙伴们也可以直接执行 x + y 相加。
注意: 因为类型别名本质上还是原来的类型,所以小伙伴们不能为基本类型的别名绑定方法。比如给 IntAlias 绑定方法,就相当于直接给内置的 int 绑定方法,编译时会直接报错。
实际上,前面学过的内置类型 byte 与 rune,本质上就是 Go 官方预先定义好的类型别名。在标准库源码中,byte 是 uint8 的类型别名,而 rune 是 int32 的类型别名,下面我们通过代码来验证一下。
示例 4:验证 byte 与 rune 类型
package main
import "fmt"
func main() {
var b byte = 65
var u uint8 = 1
var r rune = '中'
var i int32 = 1
fmt.Printf("b 的类型:%T,b + u = %d\n", b, b + u)
fmt.Printf("r 的类型:%T,r + i = %d\n", r, r + i)
}运行结果如下。
b 的类型:uint8,b + u = 66
r 的类型:int32,r + i = 20014分析:
变量 b 声明为 byte 类型,使用 %T 打印出的真实类型就是 uint8,并且可以直接与 uint8 变量 u 相加得到 66。
同理,汉字 '中' 对应的 Unicode 编码值为 20013。变量 r 声明为 rune 类型,打印出的真实类型就是 int32,可以直接与 int32 变量 i 相加得到 20014。
自定义类型与类型别名怎么选?
搞清楚两者的语法差异后,在实际开发中我们可以按以下 2 种场景来选择:
- 优先使用自定义类型(不带 =):如果需要严格区分不同的业务含义防止混用(如
UserID和OrderID),或者想要为基本类型、切片等绑定专属方法,我们就应该使用不带等号的自定义类型。 - 按需使用类型别名(带 =):如果某个类型名称太长想起一个简短外号,或者在大型项目重构时修改了类型名、需要保留旧名称让历史代码平滑兼容,就可以使用带等号的类型别名。
