Go 自定义类型与类型别名

在 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 语言中是完全等价的。

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),或者想要为基本类型、切片等绑定专属方法,我们就应该使用不带等号的自定义类型。
  • 按需使用类型别名(带 =):如果某个类型名称太长想起一个简短外号,或者在大型项目重构时修改了类型名、需要保留旧名称让历史代码平滑兼容,就可以使用带等号的类型别名。

上一篇:

下一篇:

给站长反馈

绿叶网正在不断完善中,小伙伴们如果发现任何问题,还望多多给站长反馈,谢谢!

邮箱:lvyenet@vip.qq.com

「绿叶网」服务号
绿叶网服务号放大
关注服务号,微信也能看教程。
绿叶网服务号