Go[语言基础]-数组, 字符串和切片

1. 数组

• 数组是一个由固定长度的特定类型元素组成的序列, 一个数组可以由零个或多个元素组成.

• 我们先看看数组有哪些定义方式:

package main

import "fmt"

func main() {
	var a [3]int                    // 定义一个长度为3的int类型数组, 元素全部为0
	var b = [...]int{1, 2, 3}       // 定义一个长度为3的int类型数组, 元素为 1, 2, 3
	var c = [...]int{2: 3, 1: 2}    // 定义一个长度为3的int类型数组, 元素为 0, 2, 3
	var d = [...]int{1, 2, 4: 5, 6} // 定义一个长度为6的int类型数组, 元素为 1, 2, 0, 0, 5, 6

	fmt.Println(a, b, c, d)
}

以上输出:

[0 0 0] [1 2 3] [0 2 3] [1 2 0 0 5 6]

• 第一种方式是定义一个数组变量的最基本的方式，数组的长度明确指定，数组中的每个元素都以零值初始化。

• 第二种方式定义数组，可以在定义的时候顺序指定全部元素的初始化值，数组的长度根据初始化元素的数目自动计算。

• 第三种方式是以索引的方式来初始化数组的元素，因此元素的初始化值出现顺序比较随意。这种初始化方式和map[int]Type类型的初始化语法类似。数组的长度以出现的最大的索引为准，没有明确初始化的元素依然用0值初始化。

• 第四种方式是混合了第二种和第三种的初始化方式，前面两个元素采用顺序初始化，第三第四个元素零值初始化，第五个元素通过索引初始化，最后一个元素跟在前面的第五个元素之后采用顺序初始化。

数组不仅仅可以用于数值类型，还可以定义字符串数组、结构体数组、函数数组、接口数组、管道数组等等：

// 字符串数组
var s1 = [2]string{"hello", "world"}
var s2 = [...]string{"你好", "世界"}
var s3 = [...]string{1: "世界", 0: "你好", }

// 结构体数组
var line1 [2]image.Point
var line2 = [...]image.Point{image.Point{X: 0, Y: 0}, image.Point{X: 1, Y: 1}}
var line3 = [...]image.Point{{0, 0}, {1, 1}}

// 图像解码器数组
var decoder1 [2]func(io.Reader) (image.Image, error)
var decoder2 = [...]func(io.Reader) (image.Image, error){
    png.Decode,
    jpeg.Decode,
}

// 接口数组
var unknown1 [2]interface{}
var unknown2 = [...]interface{}{123, "你好"}

// 管道数组
var chanList = [2]chan int{}

数组迭代:

for i := range a {
   fmt.Printf("a[%d]: %d\n", i, a[i])
}
for i, v := range b {
    fmt.Printf("b[%d]: %d\n", i, v)
}
for i := 0; i < len(c); i++ {
    fmt.Printf("c[%d]: %d\n", i, c[i])
}

用for range方式迭代的性能可能会更好一些，因为这种迭代可以保证不会出现数组越界的情形

2. 字符串

一个字符串是一个不可改变的字节序列，字符串的元素不可修改，是一个只读的字节数组
底层实现:

type StringHeader struct {
    Data uintptr
    Len  int
}

字符串结构由两个信息组成：第一个是字符串指向的底层字节数组，第二个是字符串的字节的长度。字符串其实是一个结构体

"Hello, world"字符串底层数据和以下数组是完全一致的：

var data = [...]byte{'h', 'e', 'l', 'l', 'o', ',', ' ', 'w', 'o', 'r', 'l', 'd'}
fmt.Printf("%#v\n", data)
fmt.Printf("%#v\n", []byte("hello, world"))

输出:

[12]uint8{0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x2c, 0x20, 0x77, 0x6f, 0x72, 0x6c, 0x64}
[]byte{0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x2c, 0x20, 0x77, 0x6f, 0x72, 0x6c, 0x64}

3. 切片(slice)

简单地说，切片就是一种简化版的动态数组
我们先看看切片的结构定义，reflect.SliceHeader:

type SliceHeader struct {
    Data uintptr
    Len  int
    Cap  int
}

Cap(capacity)成员表示切片指向的内存空间的最大容量（对应元素的个数，而不是字节数）

切片定义方式：

var (
    a []int               // nil切片, 和 nil 相等, 一般用来表示一个不存在的切片
    b = []int{}           // 空切片, 和 nil 不相等, 一般用来表示一个空的集合
    c = []int{1, 2, 3}    // 有3个元素的切片, len和cap都为3
    d = c[:2]             // 有2个元素的切片, len为2, cap为3
    e = c[0:2:cap(c)]     // 有2个元素的切片, len为2, cap为3
    f = c[:0]             // 有0个元素的切片, len为0, cap为3
    g = make([]int, 3)    // 有3个元素的切片, len和cap都为3
    h = make([]int, 2, 3) // 有2个元素的切片, len为2, cap为3
    i = make([]int, 0, 3) // 有0个元素的切片, len为0, cap为3
)
fmt.Println(i, len(i), cap(i)); // 查看slice的data, len, cap

输出:
[] 0 3

添加切片元素
内置的泛型函数append可以在切片的尾部追加N个元素：

var a []int
a = append(a, 1)               // 追加1个元素
a = append(a, 1, 2, 3)         // 追加多个元素, 手写解包方式
a = append(a, []int{1,2,3}...) // 追加一个切片, 切片需要解包

除了在切片的尾部追加，我们还可以在切片的开头添加元素：

var a = []int{1,2,3}
a = append([]int{0}, a...)        // 在开头添加1个元素
a = append([]int{-3,-2,-1}, a...) // 在开头添加1个切片

• 在开头一般都会导致内存的重新分配，而且会导致已有的元素全部复制1次。因此，从切片的开头添加元素的性能一般要比从尾部追加元素的性能差很多。

• 插入元素大于slice的cap的时候, slice会自动开辟一个更大的内存空间, 以前的数据会被GC自动回收

删除切片元素
根据要删除元素的位置有三种情况：从开头位置删除，从中间位置删除，从尾部删除。其中删除切片尾部的元素最快：

a = []int{1, 2, 3}
a = a[:len(a)-1]   // 删除尾部1个元素
a = a[:len(a)-N]   // 删除尾部N个元素

slice可以向后扩展:

var s1 = []int{0, 1, 2, 3, 4, 5, 6, 7}
s2 := s1[3:5]
s3 := s2[0:4]

fmt.Println(s1)
fmt.Println(s2)
fmt.Println(s3)

以上不会有越界错误, slice可以向后扩展(依据cap的大小)
输出:

[0 1 2 3 4 5 6 7]
[3 4]
[3 4 5 6]

---

Git https://github.com/aloneliu/learngo/tree/master/gobase 觉得帮助到你请star