Go——类型简介

阳光穿透心脏的1/2处 2023-10-09 20:57 70阅读 0赞

### 1、命名类型和未命名类型 ###

###### 命名类型（Named Type） ######

类型可以通过识符来表示，这种类型称为命名类型。Go语言的基本类型中有20个预声明简单类型都是命名类型，Go语言还有一种命名类型——用户自定义类型。

###### 未命名类型（Unamed Type） ######

一个类型由预声明类型、关键字和操作符组合而成，这个类型称为未命名类型。未命名类型又称为字面量（Type Literal）（未命名类型和类型字面量二者等价）。

Go语言的基本类型中的复合类型：数组（array）、切片（slice）、字典（map）、通道（channel）、指针（pointer）、函数字面量（function）、结构（struct）和接口（interface）都属于类型字面量，也都是未命名类型。

所以\*int、\[\]int、\[2\]int、map\[k\]v都是未命名类型。  
注意：前面所说的结果和接口是未命名类型，这里的结构和接口没有使用type格式定义，具体如下示例：

package main
    
    import "fmt"
    
    func main() {
        
    	//使用struct字面量声明的是未命名类型
    	a := struct {
        
    		name string
    		age  int
    	}{
        "andes", 18}
    	fmt.Printf("%T\n", a) //struct { name string; age int }
    	fmt.Printf("%v\n", a) //{andes 18}
    
    	b := Person{
        "tom", 21}
    	fmt.Printf("%T\n", b) //main.Person
    	fmt.Printf("%v\n", b)//{tom 21}
    }
    
    //使用type声明的是命名类型
    type Person struct {
        
    	name string
    	age  int
    }

Go语言的命名类型和未命名类型如下图：  
![在这里插入图片描述][fc4d230de1f44f2ca0172d9b5ce351b7.png]

1.  未命名类型和类型字面量是等价的，通常所说的Go语言基本类型中的复合类型就是类型字面量，所以未命名类型、类型字面量和Go语言基本类型中的复合类型三者等价。
2.  通常所说的Go语言基本类型中的简单类型就是这20个预声明类型，它们都属于命名类型。
3.  预声明类型是命名类型的一种，另一类命名类型是自定义类型。

### 2、底层类型 ###

所有【类型】都有一个underlying type(底层类型)。底层类型的规则如下：

1.  预声明类型(Pre-declared types)和类型字面量(type literals)的底层类型是它们自身。
2.  自定义类型type newtype oldtype中newtype的底层类型是逐层递归向下查找的，直到查到的oldtype是预声明类型(Pre-declared types)或类型字面量(type literals)为止。例如：

type T1 string
    type T2 T1
    type T3 []string
    type T4 T3
    type T5 []T1
    type T6 T5

T1和T2的底层类型都是string,T3和T4的底层类型都是string,T6和T5的底层类型都是\[\]T1。特别注意这里的T6、T5与T3、T4的底层类型是不一样的，一个是\[\]T1,另一个是\[\]string。  
底层类型在类型赋值和类型强制转换时会使用.

### 3、类型相同和类型赋值 ###

##### 类型相同 #####

Go是强类型的语言，编译器在编译时会进行严格的类型校验。两个命名类型是否相同，参考如下：

1.  两个命名类型相同的条件是两个类型声明的语句完全相同。
2.  命名类型和未命名类型永远不相同。
3.  两个未命名类型相同的条件是它们的类型声明字面量的结构相同，并且内部元素的类型相同。
4.  通过类型别名语句声明的两个类型相同。

Go1.9引入类型别名语法type T1 = T2，T1的类型完全和T2一样。引入别名主要有如下原因：

1.  为了解决新旧包的 迁移兼容问题，比如context包先前并不在标准库里面，后面迁移到了标准库。
2.  Go的按包进行隔离的机制不太精细，有时我们需要将大包划分为几个小包进行开发，但需要在大包里面暴露全部的类型给使用者。
3.  解决新旧类型的迁移问题，新类型先是旧类型的别名，后续的软件都基于新类型编程，在合适的时间将新类型升级为和旧类型不兼容，常用于软件的柔性升级。

##### 类型可直接赋值 #####

不同类型的变量之间一般是不能直接相互赋值的，除非满足一定的条件。下面探讨类型可赋值的条件。

类型为T1的变量a可以赋值给类型为T2的变量b,称为类型T1可以赋值给类型T2,伪代码表述如下：

//a是类型为T1的变量，或者a本身就是i一个字面常量或nil
    //如果如下语句可以执行，则称之为类型T1可以赋值给类型T2
    var b T2 = a

a可以赋值给变量b必须要满足如下条件中的一个：

1.  T1和T2的类型相同。
2.  T1和T2具有相同的底层类型，并且T1和T2里面至少有一个是未命名类型。
3.  T2是接口类型，T1是具体类型，T1的方法集是T2方法集的超集。
4.  T1和T2都是通道类型，它们拥有相同的元素类型，并且T1和T2中至少有一个是未命名类型。
5.  a是预声明标识符nil,T2是pointer、funcition、slice、map、channel、interface类型中的一个。
6.  a是一个字面常量值，可以用来表示类型T的值

示例如下：

package main
    
    import "fmt"
    
    func main() {
        
    	mp := make(map[string]string, 10)
    	mp["hi"] = "tata"
    
    	//mp与ma有相同的底层类型map[string]string，并且是未命名类型，所以mp可以直接赋值给ma
    	var ma Map = mp
    
    	//im与ma虽然具有相同的底层类型map[string]string，但它们中没有一个是未命名类型
    	//所以不能赋值，如下语句不能通过编译
    	//var im iMap = ma
    
    	ma.Print()
    
    	//Map实现了Print()，所以其可以赋值给接口类型变量
    	var i interface {
        
    		Print()
    	} = ma
    	i.Print()
    
    	s1 := []int{
        1, 2, 3}
    	var s2 slice
    	s2 = s1
    	s2.Print()
    }
    
    type Map map[string]string
    
    func (m Map) Print() {
        
    	for _, key := range m {
        
    		fmt.Println(key)
    	}
    }
    
    type iMap Map
    
    //只要底层类型是slice、map等支持range的类型字面量，新类型任然可以使用range迭代
    
    func (m iMap) Print() {
        
    	for _, key := range m {
        
    		fmt.Println(key)
    	}
    }
    
    type slice []int
    
    func (s slice) Print() {
        
    	for _, v := range s {
        
    		fmt.Println(v)
    	}
    }

### 4、类型强制转换 ###

由于Go是强类型的语言，如果不满足自动转换的条件，则必须进行强制类型转换。任意两个不相干的类型如果进行强制转换，则必须符合一定的规则。强制类型的语法格式：`var a T=(T)(b)`,使用括号将类型和要转换的变量或表达式的值括起来。

非常量类型的变量ⅹ可以强制转化并传递给类型T,需要满足如下任一条件：

1.  x可以直接赋值给T类型变量。
2.  x的类型和T具有相同的底层类型。

package main
    
    import "fmt"
    
    func main() {
        
    	mp := make(map[string]string, 10)
    	mp["hi"] = "tata"
    	//mp与ma具有相同的底层类型map[string]string，并且mp是未命名类型
    	var ma Map = mp
    
    	//im与ma虽然具有相同的底层类型，但是二者中没有一个是字面量类型，不能直接赋值，可以强制进行类型转换
    	//var im iMap = ma
    	var im iMap = (iMap)(ma)
    
    	ma.Print()
    	im.Print()
    }
    
    type Map map[string]string
    
    func (m Map) Print() {
        
    	for _, key := range m {
        
    		fmt.Println(key)
    	}
    }
    
    type iMap Map
    
    //只要底层类型是slice、map等支持range的类型字面量，新类型任然可以使用range迭代
    
    func (m iMap) Print() {
        
    	for _, key := range m {
        
    		fmt.Println(key)
    	}
    }
    
    type slice []int
    
    func (s slice) Print() {
        
    	for _, v := range s {
        
    		fmt.Println(v)
    	}
    }

1.  x的类型和T都是未命名的指针类型，并且指针指向的类型具有相同的底层类型。
2.  x的类型和T都是整型，或者都是浮点型。
3.  x的类型和T都是复数类型。
4.  x是整数值或\[\]byte类型的值，T是string类型。
5.  x是一个字符串，T是\[\]byte或\[\]rune。

字符串和字节切片之间的转换最常见，示例如下：

s := "hello,世界!"
    var a []byte
    a = []byte(s)
    var b string
    b = string(a)
    var c []rune
    c = []rune(s)
    
    fmt.Printf("%T\n", a)//[]uint8 byte是int8的别名
    fmt.Printf("%T\n", b)//string
    fmt.Printf("%T\n", c)//[]int32 rune是int32的别名

注意：

1.  数值类型和string类型之间的相互转换可能造成值部分丢失；其他的转换仅是类型的转换，不会造成值的改变。string和数字之间的转换可使用标准库strconv。
2.  Go语言没有语言机制支持指针和interger之间的直接转换，可以使用标准库中的unsafe包进行处理。

[fc4d230de1f44f2ca0172d9b5ce351b7.png]: https://img-blog.csdnimg.cn/fc4d230de1f44f2ca0172d9b5ce351b7.png