• 《Go语言四十二章经》第十七章 Type关键字
    • 17.1 Type

    《Go语言四十二章经》第十七章 Type关键字

    作者：李骁

    17.1 Type

    在Go 语言中，基础类型有下面几种：

    1.     bool byte complex64 complex128 error float32 float64
    2.     int int8 int16 int32 int64 rune string
    3.     uint uint8 uint16 uint32 uint64 uintptr

    使用 type 关键字可以定义你自己的类型，你可能想要定义一个结构体，但是也可以给一个已经存在的类型的新的名字，然后你就可以在你的代码中使用新的名字（用于简化名称或解决名称冲突），称为自定义类型，如：

    1. type IZ int

    然后我们可以使用下面的方式声明变量：

    1. var a IZ = 5

    这里我们可以看到 int 是变量 a 的底层类型，这也使得它们之间存在相互转换的可能。

    如果你有多个类型需要定义，可以使用因式分解关键字的方式，例如：

    1. type (
    2.    IZ int
    3.    FZ float64
    4.    STR string
    5. )

    在 type TZ int 中，TZ 就是 int 类型的新名称（用于表示程序中的时区），称为自定义类型，然后就可以使用 TZ 来操作 int 类型的数据。使用这种方法定义之后的类型可以拥有更多的特性，且在类型转换时必须显式转换。

    每个值都必须在经过编译后属于某个类型（编译器必须能够推断出所有值的类型），因为 Go 语言是一种静态类型语言。

    在必要以及可行的情况下，一个类型的值可以被转换成另一种类型的值。由于 Go 语言不存在隐式类型转换，因此所有的转换都必须显式说明，就像调用一个函数一样（类型在这里的作用可以看作是一种函数）：

    1. valueOfTypeB = typeB(valueOfTypeA)

    类型 B 的值 = 类型 B(类型 A 的值)

    type TZ int 中，新类型不会拥有原类型所附带的方法；TZ 可以自定义一个方法用来输出更加人性化的时区信息。

    1. type TZ = int

    （这种写法应该才是真正的别名，type TZ int 其实是定义了新类型，这两种完全不是一个含义。自定义类型不会拥有原类型附带的方法，而别名是可以的。） 类型别名在1.9中实现，可将别名类型和原类型这两个类型视为完全一致使用。下面举2个例子：

    新类型不会拥有原类型所附带的方法：

    1. package main
    3. import (
    4.     "fmt"
    5. )
    7. type A struct {
    8.     Face int
    9. }
    10. type Aa A
    12. func (a A) f() {
    13.     fmt.Println("hi ", a.Face)
    14. }
    16. func main() {
    17.     var s A = A{Face: 9}
    18.     s.f()
    20.     var sa Aa = Aa{Face: 9}
    21.     sa.f()
    22. }
    1. 编译错误信息：sa.f undefined (type Aa has no field or method f)

    但如果是类型别名，完整拥有其方法：

    1. package main
    3. import (
    4.     "fmt"
    5. )
    7. type A struct {
    8.     Face int
    9. }
    10. type Aa=A
    12. func (a A) f() {
    13.     fmt.Println("hi ", a.Face)
    14. }
    16. func main() {
    17.     var s A = A{Face: 9}
    18.     s.f()
    20.     var sa Aa = Aa{Face: 9}
    21.     sa.f()
    22. }
    1. 程序输出：
    2. hi  9
    3. hi  9

    类型可以是基本类型，如：int、float、bool、string；
    结构化的（复合的），如：struct、array、slice、map、channel；
    只描述类型的行为的，如：interface。

    结构化的类型没有真正的值，它使用 nil 作为默认值（在 Objective-C 中是 nil，在 Java 中是 null，在 C 和 C++ 中是NULL或 0）。值得注意的是，Go 语言中不存在类型继承。

    函数也可以是一个确定的类型，就是以函数作为返回类型。这种类型的声明要写在函数名和可选的参数列表之后，例如：

    1. func FunctionName (a typea, b typeb) typeFunc

    你可以在函数体中的某处返回使用类型为 typeFunc 的变量 var：

    1. return var

    一个函数可以拥有多返回值，返回类型之间需要使用逗号分割，并使用小括号 () 将它们括起来，如：

    1. func FunctionName (a typea, b typeb) (t1 type1, t2 type2)

    自定义类型不会继承原有类型的方法，但接口方法或组合类型的元素则保留原有的方法。

    1. //  Mutex 用两种方法，Lock and Unlock。
    2. type Mutex struct         { /* Mutex fields */ }
    3. func (m *Mutex) Lock()    { /* Lock implementation */ }
    4. func (m *Mutex) Unlock()  { /* Unlock implementation */ }
    6. // NewMutex和 Mutex 一样的数据结构，但是其方法是空的。
    7. type NewMutex Mutex
    9. // PtrMutex 的方法也是空的
    10. type PtrMutex *Mutex
    12. // *PrintableMutex 拥有Lock and Unlock 方法
    13. type PrintableMutex struct {
    14.     Mutex
    15. }