285-Go语言的类型

- 日理万妓 2023-01-15 03:36 127阅读 0赞

## Go语言的枚举 ##

枚举指一系列相关的常量，比如下面关于一个星期中每天的定义。我们可以用在const后跟一对圆括号的方式定义一组常量，**这种定义法在Go语言中通常用于定义枚举值**。  
**Go语言并不支持众多其他语言明确支持的enum关键字。**  
下面是一个常规的**枚举**表示法，其中定义了一系列整型常量：

const ( 
     Sunday = iota
     Monday 
     Tuesday 
     Wednesday 
     Thursday 
     Friday 
     Saturday 
     numberOfDays // 这个常量没有导出 
    )

同Go语言的其他符号（symbol）一样，**以大写字母开头的常量在包外可见。**  
**以上例子中numberOfDays为包内私有，其他符号则可被其他包访问。**

## Go语言的类型 ##

**Go语言内置以下这些基础类型：**  
 布尔类型：bool。  整型：int8、byte、int16、int、uint、uintptr等。  
 浮点类型：float32、float64。  
 复数类型：complex64、complex128。  
 字符串：string。  
 字符类型：rune。  
 错误类型：error。

**此外，Go语言也支持以下这些复合类型：**  
 指针（pointer）  
 数组（array）  
 切片（slice）  
 字典（map）  
 通道（chan）  
 结构体（struct）  
 接口（interface）  
**在这些基础类型之上Go还封装了下面这几种类型**：  
**int、uint和uintptr等**。这些类型的特点在于使用方便，但使用者不能对这些类型的长度做任何假设。对于常规的开发来说，用int和uint就可以了，没必要用int8之类明确指定长度的类型，以免导致移植困难。

## 布尔类型 ##

**Go 语言中以 bool 类型进行声明布尔类型数据，布尔型数据只有 true  
和 false 两个值，需要注意的是：**  
◼ go 语言中不允许将整型强制转换为布尔型  
◼ 布尔类型变量默认值为 false  
◼ 布尔型无法参与数值运算，也无法与其他类型进行转换  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center]

**Go语言中的布尔类型与其他语言基本一致，关键字也为bool，可赋值为预定义的true和false示例代码如下：**

var v1 bool
    v1 = true
    v2 := (1 == 2) // v2也会被推导为bool类型

**布尔类型不能接受其他类型的赋值，不支持自动或强制的类型转换。**  
以下的示例是一些错误的用法，会导致编译错误：

var b bool
    b = 1 // 编译错误
    b = bool(1) // 编译错误
    以下的用法才是正确的：
    var b bool
    b = (1!=0) // 编译正确 
    fmt.Println("Result:", b) // 打印结果为Result: true

## 整型 ##

**整型**是所有编程语言里最基础的数据类型。Go语言支持表2-1所示的这些整型类型。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 1]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 2]  
![在这里插入图片描述][20210421132611243.png_pic_center]

**1. 类型表示**  
需要注意的是，int和int32在Go语言里被认为是**两种不同的类型**，**编译器也不会帮你自动做类型转换**，比如以下的例子会有**编译错误：**

var value2 int32
    value1 := 64 // value1将会被自动推导为int类型
    value2 = value1 // 编译错误

**编译错误类似于：**

cannot use value1 (type int) as type int32 in assignment

**使用强制类型转换可以解决这个编译错误：**

value2 = int32(value1) // 编译通过

当然，开发者在做强制类型转换时，需要注意数据长度被截短而发生的数据精度损失（比如将浮点数强制转为整数）和值溢出（值超过转换的目标类型的值范围时）问题。

**类型转换**

Go 语言中只有强类型转换，没有隐式转换。该语法只能在两个类型  
之间支持相互转换的时候使用。强制转换的语法如下：  
![在这里插入图片描述][20210421133620545.png_pic_center]  
**示例如下：**  
![在这里插入图片描述][20210421133648354.png_pic_center]

**2. 数值运算**  
**Go语言支持下面的常规整数运算：+、-、\*、/和%**  
加减乘除就不详细解释了，需要说下的是，% 和在C语言中一样是求余运算，比如：

5 % 3 // 结果为：2

**3. 比较运算**  
**Go语言支持以下的几种比较运算符：>、<、==、>=、<=和!=**  
这一点与大多数其他语言相同，与C语言完全一致。  
下面为条件判断语句的例子：

i, j := 1, 2 
    if i == j {
         
     fmt.Println("i and j are equal.") 
    }

**两个不同类型的整型数不能直接比较**，比如int8类型的数和int类型的数不能直接比较，但各种类型的整型变量都可以直接与字面常量（literal）进行比较，比如

var i int32
    var j int64
    i, j = 1, 2 
    if i == j {
         // 编译错误
     fmt.Println("i and j are equal.") 
    } 
    if i == 1 || j == 2 {
         // 编译通过
     fmt.Println("i and j are equal.") 
    }

**4. 位运算**  
Go语言支持表2-2所示的位运算符。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 3]  
Go语言的大多数位运算符与C语言都比较类似，除了**取反**在C语言中是~x，**而在Go语言中是^x。**

**编程语言中表示固定值的符号叫做字面量常量，简称字面量**。如整形  
字面量八进制：“012”或者“0o17”，十六进制: “0x12”，二进制：”0b101”，  
**输出表示如下图：**  
![在这里插入图片描述][20210421132701408.png_pic_center]

## 浮点型 ##

字面量八进制：“012”或者“0o17”，十六进制: “0x12”，二进制：”0b101”，  
输出表示如下图：  
**浮点型用于表示包含小数点的数据**，比如1.234就是一个浮点型数据。Go语言中的浮点类型采用IEEE-754标准的表达方式

**1. 浮点数表示**  
Go语言定义了两个类型float32和float64，其中float32等价于C语言的float类型，float64等价于C语言的double类型  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 4]

**在Go语言里，定义一个浮点数变量的代码如下：**

var fvalue1 float32
    fvalue1 = 12 
    fvalue2 := 12.0 // 如果不加小数点，fvalue2会被推导为整型而不是浮点型

对于以上例子中类型被自动推导的fvalue2，需要注意的是其类型将被自动设为float64，而不管赋给它的数字是否是用32位长度表示的。因此，对于以上的例子，**下面的赋值将导致编译错误：**

fvalue1 = fvalue2

**而必须使用这样的强制类型转换：**

fvalue1 = float32(fvalue2)

**2. 浮点数比较**  
因为浮点数**不是**一种精确的表达方式，所以像整型那样直接用==来判断两个浮点数是否相等是**不可行**的，这可能会导致不稳定的结果  
**下面是一种推荐的替代方案：**

import "math" 
    // p为用户自定义的比较精度，比如0.00001 
    func IsEqual(f1, f2, p float64) bool {
         
     return math.Fdim(f1, f2) < p 
    }

## 复数类型 ##

复数实际上由两个实数（在计算机中用浮点数表示）构成，一个表示实部（real），一个表示虚部（imag）。如果了解了数学上的复数是怎么回事，那么Go语言的复数就非常容易理解了。  
复数有实部和虚部，**complex64 的实部和虚部为 32 位，complex128的实部和虚部为 64 位。**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 5]

**1. 复数表示**  
复数表示的示例如下：

var value1 complex64 // 由2个float32构成的复数类型
    value1 = 3.2 + 12i 
    value2 := 3.2 + 12i // value2是complex128类型
    value3 := complex(3.2, 12) // value3结果同 value2

**2. 实部与虚部**  
对于一个复数z = complex(x, y)，就可以通过Go语言内置函数real(z)获得该复数的实部，也就是x，通过imag(z)获得该复数的虚部，也就是y。

## 字符串 ##

Go 语言中的字符串以原生数据类型出现，使用字符串就像使用其他  
原生数据类型一样。Go 语言里的字符串的内部实现使用 utf-8 编码。字符串的值为双引号中的内容，如  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 6]

在Go语言中，字符串也是一种基本类型。相比之下， C/C++语言中并不存在原生的字符类型，通常使用字符数组来表示，并以字符指针来传递。  
**Go语言中字符串的声明和初始化非常简单，举例如下：**

var str string // 声明一个字符串变量
    str = "Hello world" // 字符串赋值
    ch := str[0] // 取字符串的第一个字符
    fmt.Printf("The length of \"%s\" is %d \n", str, len(str)) 
    fmt.Printf("The first character of \"%s\" is %c.\n", str, ch)

**输出结果为：**

The length of "Hello world" is 11 
    The first character of "Hello world" is H.

**字符串的内容可以用类似于数组下标的方式获取，但与数组不同，字符串的内容不能在初始化后被修改，比如以下的例子：**

str := "Hello world" // 字符串也支持声明时进行初始化的做法
    str[0] = 'X' // 编译错误

**编译器会报类似如下的错误：**

cannot assign to str[0]

在这个例子中我们使用了一个Go语言内置的函数len()来取字符串的长度。这个函数非常有用，我们在实际开发过程中处理字符串、数组和切片时将会经常用到。  
**Printf()函数的用法与C语言运行库中的printf()函数如出一辙。**  
Go编译器支持UTF-8的源代码文件格式。这意味着源代码中的字符串可以包含非ANSI的字符，比如“Hello world. 你好，世界！”可以出现在Go代码中。但需要注意的是，如果你的Go代码需要包含非ANSI字符，保存源文件时请注意编码格式必须选择UTF-8。特别是在Windows下一般编辑器都默认存为本地编码，比如中国地区可能是GBK编码而不是UTF-8，如果没注意这点在编译和运行时就会出现一些意料之外的情况。

**字符串的编码转换是处理文本文档（比如TXT、XML、HTML等）非常常见的需求，不过可惜的是Go语言仅支持UTF-8和Unicode编码**。对于其他编码，Go语言标准库并没有内置的编码转换支持。不过，所幸的是我们可以很容易基于iconv库用Cgo包装一个。这里有一个开源项目：https://github.com/xushiwei/go-iconv。

**1. 字符串操作**  
平时常用的字符串操作如表2-3所示。  
![在这里插入图片描述][20210421124907452.png_pic_center]  
更多的字符串操作，请参考标准库strings包。

**2. 字符串遍历**  
**Go语言支持两种方式遍历字符串。一种是以字节数组的方式遍历：**

str := "Hello,世界"
    n := len(str) 
    for i := 0; i < n; i++ {
         
     ch := str[i] // 依据下标取字符串中的字符，类型为byte 
     fmt.Println(i, ch) 
    }

**这个例子的输出结果为：**

0 72 
    1 101 
    2 108 
    3 108 
    4 111 
    5 44 
    6 32 
    7 228 
    8 184 
    9 150 
    10 231 
    11 149 
    12 140

可以看出，这个字符串长度为13。尽管从直观上来说，这个字符串应该只有9个字符。这是因为每个中文字符在UTF-8中占3个字节，而不是1个字节  
**另一种是以Unicode字符遍历：**

str := "Hello,世界"
    for i, ch := range str {
         
     fmt.Println(i, ch)//ch的类型为rune 
    }

**输出结果为：**

0 72 
    1 101 
    2 108 
    3 108 
    4 111 
    5 44 
    6 32 
    7 19990 
    10 30028

以Unicode字符方式遍历时，每个字符的类型是**rune**（早期的Go语言用int类型表示Unicode字符），而不是byte。

**字符串的常见操作**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 7]

## 字符类型 ##

在Go语言中支持两个字符类型，一个是byte（实际上是uint8的别名），代表UTF-8字符串的单个字节的值；另一个是rune，代表单个Unicode字符。  
关于rune相关的操作，可查阅Go标准库的unicode包。另外unicode/utf8包也提供了UTF8和Unicode之间的转换。  
出于简化语言的考虑，Go语言的多数API都假设字符串为UTF-8编码。尽管Unicode字符在标准库中有支持，但实际上较少使用。

## byte 和 rune 类型 ##

字符指类字形单位或符号，包括字母、数字、运算符号、标点符  
号和其他符号，以及一些功能性符号。每个字符在计算机中都有相应的二进制代码  
![在这里插入图片描述][20210421133303708.png_pic_center]

**Go 语言内置两种字符类型：**  
◼ 一种是 byte 的字节类型，它是 uint8 的别名。  
◼ 另一种是 Unicode 编码的 rune 类型，它是 int32 类型的别名。  
Go 语言默认的字符编码就是 UTF-8 类型的。  
**遍历字符串，如下：**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 8]  
UTF-8 编码下一个中文汉字由 3-4 个字节组成，所以我们不能简  
单的按照字节去遍历一个包含中文字符的字符串。  
字符串底层是一个 byte 数组，所以可以和\[\]byte 类型相互转换。  
字符串是不能修改的，字符串由 byte 字节组成，所以字符串的长度  
就是 byte 字节的长度。rune 类型用来表示 utf-8 字符，一个 rune 字  
符由一个或多个 byte 组成。

**修改字符串**  
**要修改字符串，需要先将其转换成\[\]rune 或者\[\]byte，修改以后，  
再转换为 string**。  
无论哪种转换，都会重新分配内存并复制字节  
数组。如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 9]

## 常见的转义字符 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 10]  
多行字符串的显示，可以使用反引号进行，需要注意的是反引号  
间换行将被作为字符串中的换行，但是所有的转义字符均无效，文本将会原样输出  
![在这里插入图片描述][20210421133139938.png_pic_center]

## 数组 ##

**数组**是Go语言编程中最常用的数据结构之一。顾名思义，数组就是指一系列同一类型数据的集合。数组中包含的每个数据被称为数组元素（element），一个数组包含的元素个数被称为数组的长度。  
**以下为一些常规的数组声明方法：**

[32]byte // 长度为32的数组，每个元素为一个字节
    [2*N] struct {
         x, y int32 } // 复杂类型数组
    [1000]*float64 // 指针数组
    [3][5]int // 二维数组
    [2][2][2]float64 // 等同于[2]([2]([2]float64))

从以上类型也可以看出，数组可以是多维的，比如\[3\]\[5\]int就表达了一个3行5列的二维整型数组，总共可以存放15个整型元素。  
在Go语言中，数组长度在定义后就不可更改，在声明时长度可以为一个常量或者一个常量表达式（常量表达式是指在编译期即可计算结果的表达式）。数组的长度是该数组类型的一个内置常量，可以用Go语言的**内置函数len()** 来获取。  
**下面是一个获取数组arr元素个数的写法：**

arrLength := len(arr)

**1. 元素访问**  
可以使用数组下标来访问数组中的元素。与C语言相同，数组下标从0开始，len(array)-1则表示最后一个元素的下标。下面的示例遍历整型数组并逐个打印元素内容：

for i := 0; i < len(array); i++ {
         
     fmt.Println("Element", i, "of array is", array[i]) 
    }

Go语言还提供了一个**关键字range**，**用于便捷地遍历容器中的元素**。当然，**数组也是range的支持范围**。上面的遍历过程可以简化为如下的写法：

for i, v := range array {
         
     fmt.Println("Array element[", i, "]=", v) 
    }

在上面的例子里可以看到  
**range具有两个返回值，第一个返回值是元素的数组下标，第二个返回值是元素的值。**

**2. 值类型**  
需要特别注意的是，在Go语言中数组是一个值类型（value type）。**所有的值类型变量在赋值和作为参数传递时都将产生一次复制动作**。  
如果将数组作为函数的参数类型，则在函数调用时该参数将发生数据复制。因此，在函数体中无法修改传入的数组的内容，因为函数内操作的只是所传入数组的一个**副本。**  
**下面用例子来说明这一特点：**

package main 
    import "fmt" 
    func modify(array [10]int) {
         
     array[0] = 10 // 试图修改数组的第一个元素
     fmt.Println("In modify(), array values:", array) 
    } 
    func main() {
         
     array := [5]int{
        1,2,3,4,5} // 定义并初始化一个数组
     modify(array) // 传递给一个函数，并试图在函数体内修改这个数组内容
     fmt.Println("In main(), array values:", array) 
    }

**该程序的执行结果为：**

In modify(), array values: [10 2 3 4 5] 
    In main(), array values: [1 2 3 4 5]

从执行结果可以看出，函数modify()内操作的那个数组跟main()中传入的数组是两个不同的实例。

## 数组切片 ##

我们已经提过数组的**特点**：数组的长度在定义之后无法再次修改；数组是值类型，每次传递都将产生一份副本。显然这种数据结构无法完全满足开发者的真实需求。  
不用失望，Go语言提供了**数组切片（slice）** 这个非常酷的功能来弥补数组的不足。  
初看起来，数组切片就像一个指向数组的指针，**实际上它拥有自己的数据结构，而不仅仅是个指针**。  
**数组切片的数据结构可以抽象为以下3个变量：**  
 一个指向原生数组的指针；  
 数组切片中的元素个数；  
 数组切片已分配的存储空间。  
**从底层实现的角度来看，数组切片实际上仍然使用数组来管理元素**，因此它们之间的关系让C++程序员们很容易联想起STL中std::vector和数组的关系。基于数组，数组切片添加了一系列管理功能，可以随时动态扩充存放空间，并且可以被随意传递而不会导致所管理的元素被重复复制。  
**1. 创建数组切片**  
创建数组切片的方法主要有两种——基于数组和直接创建，下面我们来简要介绍一下这两种方法。  
** 基于数组**  
数组切片可以基于一个已存在的数组创建。数组切片可以只使用数组的一部分元素或者整个数组来创建，甚至可以创建一个比所基于的数组还要大的数组切片。代码清单2-1演示了如何基于一个数组的前5个元素创建一个数组切片。  
**代码清单2-1 slice.go**

package main 
    import "fmt" 
    func main() {
         
     // 先定义一个数组
     var myArray [10]int = [10]int{
        1, 2, 3, 4, 5, 6, 7, 8, 9, 10} 
     // 基于数组创建一个数组切片
     var mySlice []int = myArray[:5] 
     fmt.Println("Elements of myArray: ") 
     for _, v := range myArray {
         
     fmt.Print(v, " ") 
     } 
     fmt.Println("\nElements of mySlice: ") 
     for _, v := range mySlice {
         
     fmt.Print(v, " ") 
     } 
     fmt.Println() 
    }

**运行结果为：**

Elements of myArray: 
    1 2 3 4 5 6 7 8 9 10 
    Elements of mySlice: 
    1 2 3 4 5

**Go语言支持用myArray\[first:last\]这样的方式来基于数组生成一个数组切片，而且这个用法还很灵活，比如下面几种都是合法的。**

**基于myArray的所有元素创建数组切片：**

mySlice = myArray[:]

**基于myArray的前5个元素创建数组切片：**

mySlice = myArray[:5]

**基于从第5个元素开始的所有元素创建数组切片：**

mySlice = myArray[5:]

** 直接创建**  
并非一定要事先准备一个数组才能创建数组切片。Go语言提供的内置函数make()可以用于灵活地创建数组切片。下面的例子示范了直接创建数组切片的各种方法。  
**创建一个初始元素个数为5的数组切片，元素初始值为0：**

mySlice1 := make([]int, 5)

**创建一个初始元素个数为5的数组切片，元素初始值为0，并预留10个元素的存储空间：**

mySlice2 := make([]int, 5, 10)

**直接创建并初始化包含5个元素的数组切片：**

mySlice3 := []int{
        1, 2, 3, 4, 5}

当然，事实上还会有一个匿名数组被创建出来，只是不需要我们来操心而已。

**2. 元素遍历**  
操作数组元素的所有方法都适用于数组切片，比如数组切片也可以按下标读写元素，**用len()函数获取元素个数，并支持使用range关键字来快速遍历所有元素。**  
**传统的元素遍历方法如下:**

for i := 0; i <len(mySlice); i++ {
         
     fmt.Println("mySlice[", i, "] =", mySlice[i]) 
    }

使用range关键字可以让遍历代码显得更整洁。range表达式有两个返回值，第一个是索引，第二个是元素的值：

for i, v := range mySlice {
         
     fmt.Println("mySlice[", i, "] =", v) 
    }

对比上面的两个方法，我们可以很容易地看出使用range的代码更简单易懂。

**3. 动态增减元素**  
可动态增减元素是数组切片比数组更为强大的功能。与数组相比，数组切片多了一个存储能力（capacity）的概念，即元素个数和分配的空间可以是两个不同的值。合理地设置存储能力的值，可以大幅降低数组切片内部重新分配内存和搬送内存块的频率，从而大大提高程序性能。

假如你明确知道当前创建的数组切片最多可能需要存储的元素个数为50，那么如果你设置的存储能力小于50，比如20，那么在元素超过20时，底层将会发生至少一次这样的动作——重新分配一块“够大”的内存，并且需要把内容从原来的内存块复制到新分配的内存块，这会产生比较明显的开销。给“够大”这两个字加上引号的原因是系统并不知道多大才是够大，所以只是一个简单的猜测。比如，将原有的内存空间扩大两倍，但两倍并不一定够，所以之前提到的内存重新分配和内容复制的过程很有可能发生多次，从而明显降低系统的整体性能。但如果你知道最大是50并且一开始就设置存储能力为50，那么之后就不会发生这样非常耗费CPU的动作，从而达到空间换时间的效果。  
数组切片支持Go语言内置的cap()函数和len()函数，代码清单2-2简单示范了这两个内置函数的用法。可以看出，cap()函数返回的是数组切片分配的空间大小，而len()函数返回的是数组切片中当前所存储的元素个数。

**代码清单2-2 slice2.go**

package main 
    import "fmt" 
    func main() {
         
     mySlice := make([]int, 5, 10) 
     fmt.Println("len(mySlice):", len(mySlice)) 
     fmt.Println("cap(mySlice):", cap(mySlice)) 
    }

**该程序的输出结果为：**

len(mySlice): 5 
    cap(mySlice): 10

如果需要往上例中mySlice已包含的5个元素后面继续新增元素，可以使用append()函数。  
下面的代码可以从尾端给mySlice加上3个元素，从而生成一个新的数组切片：

mySlice = append(mySlice, 1, 2, 3)

函数append()的第二个参数其实是一个不定参数，我们可以按自己需求添加若干个元素，甚至直接将一个数组切片追加到另一个数组切片的末尾：

mySlice2 := []int{
        8, 9, 10} 
    // 给mySlice后面添加另一个数组切片
    mySlice = append(mySlice, mySlice2...)

需要注意的是，我们在第二个参数mySlice2后面加了三个点，即一个省略号，如果没有这个省略号的话，会有编译错误，因为按append()的语义，从第二个参数起的所有参数都是待附加的元素。因为mySlice中的元素类型为int，所以直接传递mySlice2是行不通的。加上省略号相当于把mySlice2包含的所有元素打散后传入。  
**上述调用等同于：**

mySlice = append(mySlice, 8, 9, 10)

数组切片会自动处理存储空间不足的问题。如果追加的内容长度超过当前已分配的存储空间（即cap()调用返回的信息），数组切片会自动分配一块足够大的内存。

**4. 基于数组切片创建数组切片**  
类似于数组切片可以基于一个数组创建，数组切片也可以基于另一个数组切片创建。下面的例子基于一个已有数组切片创建新数组切片：

oldSlice := []int{
        1, 2, 3, 4, 5} 
    newSlice := oldSlice[:3] // 基于oldSlice的前3个元素构建新数组切片

有意思的是，选择的oldSlicef元素范围甚至可以超过所包含的元素个数，比如newSlice可以基于oldSlice的前6个元素创建，虽然oldSlice只包含5个元素。只要这个选择的范围不超过oldSlice存储能力（即cap()返回的值），那么这个创建程序就是合法的。newSlice中超出oldSlice元素的部分都会填上0。  
**5. 内容复制**  
数组切片支持Go语言的另一个内置函数copy()，用于将内容从一个数组切片复制到另一个数组切片。如果加入的两个数组切片不一样大，就会按其中较小的那个数组切片的元素个数进行复制。下面的示例展示了copy()函数的行为：

slice1 := []int{
        1, 2, 3, 4, 5} 
    slice2 := []int{
        5, 4, 3} 
    copy(slice2, slice1) // 只会复制slice1的前3个元素到slice2中
    copy(slice1, slice2) // 只会复制slice2的3个元素到slice1的前3个位置

## map ##

在C++/Java中，map一般都以库的方式提供，比如在C++中是STL的std::map<>，在C\#中是Dictionary<>，在Java中是Hashmap<>，在这些语言中，如果要使用map，事先要引用相应的库。而在Go中，使用map不需要引入任何库，并且用起来也更加方便。  
**map是一堆键值对的未排序集合**。比如以身份证号作为唯一键来标识一个人的信息，则这个map可以定义为代码清单 2-3所示的方式。  
**代码清单2-3 map1.go**

package main 
    import "fmt" 
    // PersonInfo是一个包含个人详细信息的类型
    type PersonInfo struct {
         
     ID string
     Name string
     Address string
    } 
    func main() {
         
    var personDB map[string] PersonInfo 
     personDB = make(map[string] PersonInfo) 
     // 往这个map里插入几条数据
     personDB["12345"] = PersonInfo{
        "12345", "Tom", "Room 203,..."} 
     personDB["1"] = PersonInfo{
        "1", "Jack", "Room 101,..."} 
     // 从这个map查找键为"1234"的信息
     person, ok := personDB["1234"]
     // ok是一个返回的bool型，返回true表示找到了对应的数据
     if ok {
         
     fmt.Println("Found person", person.Name, "with ID 1234.") 
     } else {
         
     fmt.Println("Did not find person with ID 1234.") 
     } 
    }

**上面这个简单的例子基本上已经覆盖了map的主要用法，下面对其中的关键点进行细述。**  
**1. 变量声明**  
map的声明基本上没有多余的元素，比如：

var myMap map[string] PersonInfo

其中，myMap是声明的map变量名，string是键的类型，PersonInfo则是其中所存放的值类型。  
**2. 创建**  
我们可以使用Go语言内置的函数make()来创建一个新map。下面的这个例子**创建了一个键类型为string、值类型为PersonInfo的map:**

myMap = make(map[string] PersonInfo)

也可以选择是否在创建时指定该map的初始存储能力，**下面的例子创建了一个初始存储能力为100的map:**

myMap = make(map[string] PersonInfo, 100)

**创建并初始化map的代码如下：**

myMap = map[string] PersonInfo{
         
     "1234": PersonInfo{
        "1", "Jack", "Room 101,..."}, 
    }

**3. 元素赋值**  
赋值过程非常简单明了，就是将键和值用下面的方式对应起来即可：

myMap["1234"] = PersonInfo{
        "1", "Jack", "Room 101,..."}

**4. 元素删除**  
Go语言提供了一个内置函数delete()，用于删除容器内的元素。下面我们简单介绍一下如何用**delete()函数删除map内的元素：**

delete(myMap, "1234")

上面的代码将从myMap中删除键为“1234”的键值对。如果“1234”这个键不存在，那么这个调用将什么都不发生，也不会有什么副作用。但是如果传入的map变量的值是nil，该调用将导致程序抛出异常（panic）

**5. 元素查找**  
在Go语言中，map的查找功能设计得比较精巧。而在其他语言中，我们要判断能否获取到一个值不是件容易的事情。判断能否从map中获取一个值的常规做法是：  
(1) 声明并初始化一个变量为空；  
(2) 试图从map中获取相应键的值到该变量中；  
(3) 判断该变量是否依旧为空，如果为空则表示map中没有包含该变量。

这种用法比较啰唆，而且判断变量是否为空这条语句并不能真正表意（是否成功取到对应的值），从而影响代码的可读性和可维护性。有些库甚至会设计为因为一个键不存在而抛出异常，让开发者用起来胆战心惊，不得不一层层嵌套try-catch语句，这更是不人性化的设计。在Go语言中，要从map中查找一个特定的键，可以通过下面的代码来实现：

value, ok := myMap["1234"] 
    if ok {
         // 找到了
     // 处理找到的value 
    }

判断是否成功找到特定的键，不需要检查取到的值是否为nil，只需查看第二个返回值ok，这让表意清晰很多。配合:=操作符，让你的代码没有多余成分，看起来非常清晰易懂。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center]: /images/20221022/d878b451bb4c4d8ca65bb6fdc22f9db2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221022/27afb217ca5a463f925390b8468a851b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221022/491f7334a9ff4315974c0459bcacd964.png
[20210421132611243.png_pic_center]: /images/20221022/b9884f1d6cf64349aeced6283a865ebf.png
[20210421133620545.png_pic_center]: /images/20221022/1828e703513c4435849a04e41b0974e8.png
[20210421133648354.png_pic_center]: /images/20221022/58c50f5855a74870ba5c27dd71207afb.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20221022/63142f9007874bfc8f7940bdde877b5a.png
[20210421132701408.png_pic_center]: /images/20221022/168efd3a759843488d932c1c59d0921c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 4]: /images/20221022/92bdc3f38a634f2089a4251dfb7f6771.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 5]: /images/20221022/fbc4dffcf9cb4f8abbe3f1a2c2ce3ddb.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 6]: /images/20221022/5dc67396c07f49749bb4ddd02a38c011.png
[20210421124907452.png_pic_center]: /images/20221022/8b38cc87513e4d648651dfcb928ccce4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 7]: /images/20221022/f22f9075c66d44bbb0720ed02f17508a.png
[20210421133303708.png_pic_center]: /images/20221022/70c94e3f70b1422ea6585ab2af0b9b18.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 8]: /images/20221022/a61025f9e1e0495cb7e5dd4be92c6ab9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 9]: /images/20221022/e790ca99a5ac4ad99dc0df9a6f5b26da.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 10]: /images/20221022/a34fc2dbac8d4ab0bd77e39acad31262.png
[20210421133139938.png_pic_center]: /images/20221022/228cfa86826a4f44aa643e71594a134a.png