初始Go--基本数据结构

数组

1. 数组：是同一种数据类型的固定长度的序列。
2. 数组定义：var a [len]int，比如：var a [5]int，数组长度必须是常量，且是类型的组成部分。一旦定义，长度不能变。
3. 长度是数组类型的一部分，因此，var a[5] int和var a[10]int是不同的类型。
4. 数组可以通过下标进行访问，下标是从0开始，最后一个元素下标是：len-1
5. 访问越界，如果下标在数组合法范围之外，则触发访问越界，会panic
6. 数组是值类型，赋值和传参会复制整个数组，而不是指针。因此改变副本的值，不会改变本身的值。
7. 支持 “==”、“!=” 操作符，因为内存总是被初始化过的。
8. 指针数组 [n]*T，数组指针 *[n]T。

数组初始化

一维数组

package main

import "fmt"

//全局
var arr0 [5]int = [5]int{1, 2, 3, 4, 5}
var arr1 = [5]int{2, 3, 4, 5, 5}
var arr2 = [...]int{2, 2, 3, 3, 6, 6}
var arr3 = [5]string{0: "hello world", 4: "tom"}

func main() {
	//局部
	a := [2]int{1, 2}
	b := [...]int{1, 2, 3, 5, 6}
	c := [5]int{2: 100, 4: 200} // 使用引号初始化元素。
	d := [...]struct {
		name string
		age  uint8
	}{
		{"user1", 10}, // 可省略元素类型。
		{"user2", 20}, // 别忘了最后一行的逗号。
	}
	fmt.Println(a, b, c, d)
	fmt.Println(arr0, arr1, arr2, arr3)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

PS D:\phpstudy_pro\WWW\go\src\hello> go run test.go
[1 2] [1 2 3 5 6] [0 0 100 0 200] [{user1 10} {user2 20}]
[1 2 3 4 5] [2 3 4 5 5] [2 2 3 3 6 6] [hello world    tom]
1
2
3

多维数组

package main

import "fmt"

//全局
var arr0 [2][3]int = [...][3]int{{1, 2, 3}, {4, 5, 6}}

var arr1 [2][3]int

func main() {
	//局部
	a := [2][3]int{{1, 2, 3}, {4, 5, 6}}
	b := [...][2]int{{1, 1}, {2, 2}, {3, 3}} // 第 2 纬度不能用 "..."。
	fmt.Println(arr0, arr1)
	fmt.Println(a, b)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

S D:\phpstudy_pro\WWW\go\src\hello> go run test.go
[[1 2 3] [4 5 6]] [[0 0 0] [0 0 0]]
[[1 2 3] [4 5 6]] [[1 1] [2 2] [3 3]]
1
2
3

数组长度

内置函数 len 和 cap 都返回数组长度 (元素数量)。

package main

func main() {
	a := [2]int{}
	println(len(a), cap(a))
}
1
2
3
4
5
6

多维数组遍历

package main

import "fmt"

func main() {
	arr1 := [...][3]int{{1, 2, 4}, {7, 8, 9}}
	for k1, v1 := range arr1 {
		for k2, v2 := range v1 {
			fmt.Printf("(%d,%d)=%d ", k1, k2, v2)
		}
		fmt.Println()
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13

PS D:\phpstudy_pro\WWW\go\src\hello> go run test.go
(0,0)=1 (0,1)=2 (0,2)=4 
(1,0)=7 (1,1)=8 (1,2)=9
1
2
3

切片

切片是指向数组的指针，对切片的操作，就是操作底层的数组。

1. 切片：切片是数组的一个引用，因此切片是引用类型。但自身是结构体，值拷贝传递。
2. 切片的长度可以改变，因此，切片是一个可变的数组。
3. 切片遍历方式和数组一样，可以用len()求长度。表示可用元素数量，读写操作不能超过该限制。
4. cap可以求出slice最大扩张容量，不能超出数组限制。0 <= len(slice) <= len(array)，其中array是slice引用的数组。
5. 切片的定义：var 变量名 []类型，比如 var str []string var arr []int。
6. 如果 slice == nil，那么 len、cap 结果都等于 0。

切片的创建

package main

import "fmt"

func main() {
	//1.声明切片
	var s1 []int
	if s1 == nil {
		fmt.Println("是空")
	} else {
		fmt.Println("不是空")
	}
	//2. :=
	s2 := []int{}
	fmt.Println(s2)
	//3. make
	var s3 = make([]int, 0)
	fmt.Println(s3)
	//4.初始化赋值
	var s4 []int = make([]int, 0, 0)
	fmt.Println(s4)
	s5 := []int{1, 2, 3}
	fmt.Println(s5)

	// 5.从数组切片
	arr := [5]int{1, 2, 3, 4, 5}
	var s6 []int
	// 前包后不包
	s6 = arr[1:4]
	fmt.Println(s6)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

PS D:\phpstudy_pro\WWW\go\src\hello> go run test.go
是空
[]
[]
[]
[1 2 3]
[2 3 4]

1
2
3
4
5
6
7
8

切片初始化

package main

import "fmt"

func main() {
	arr := [...]int{9, 8, 7, 6, 5, 4, 3, 2, 1, 0}
	slice1 := arr[2]
	slice5 := arr[2:8]
	slice6 := arr[0:6]
	slice7 := arr[5:10]
	slice8 := arr[0:len(arr)]
	slice9 := arr[:len(arr)-1]
	slice10 := arr[0 : len(arr)-1 : 9]
	fmt.Printf("局部变量： arr2 %v\n", arr)
	fmt.Printf("局部变量： slice1 %v\n", slice1)
	fmt.Printf("局部变量： slice5 %v\n", slice5)
	fmt.Printf("局部变量： slice6 %v\n", slice6)
	fmt.Printf("局部变量： slice7 %v\n", slice7)
	fmt.Printf("局部变量： slice8 %v\n", slice8)
	fmt.Printf("局部变量： slice9 %v\n", slice9)
	fmt.Printf("局部变量： slice10 %v\n", slice10)
	fmt.Printf("局部变量： slice10长度 %v\n", len(slice10))
	fmt.Printf("局部变量： slice10容量 %v\n", cap(slice10))
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

PS D:\phpstudy_pro\WWW\go\src\hello> go run test.go
局部变量： arr2 [9 8 7 6 5 4 3 2 1 0]
局部变量： slice1 7
局部变量： slice8 [9 8 7 6 5 4 3 2 1 0]
局部变量： slice9 [9 8 7 6 5 4 3 2 1]
局部变量： slice10 [9 8 7 6 5 4 3 2 1]
局部变量： slice10长度 9
局部变量： slice10容量 9
1
2
3
4
5
6
7
8

make创建切片

 var slice []type = make([]type, len)
 slice  := make([]type, len)
 slice  := make([]type, len, cap)
1
2
3

package main

import "fmt"

var slice0 []int = make([]int, 5)
var slice1 = make([]int, 5)
var slice2 = make([]int, 6, 7)

func main() {
	fmt.Printf("make全局slice0 ：%v\n", slice0)
	fmt.Printf("make全局slice1 ：%v\n", slice1)
	fmt.Printf("make全局slice2 ：%v\n", slice2)
}
1
2
3
4
5
6
7
8
9
10
11
12
13

PS D:\phpstudy_pro\WWW\go\src\hello> go run test.go
make全局slice0 ：[0 0 0 0 0]
make全局slice1 ：[0 0 0 0 0]
make全局slice2 ：[0 0 0 0 0 0]
1
2
3
4

append内置函数操作切片（切片追加）

package main

import "fmt"

func main() {
	var a = []int{1, 2, 3}
	fmt.Printf("slice a : %v\n", a)
	s := a[:2:3] //s.cap=3
	fmt.Printf("slice s : %v\n", s)
	fmt.Println(len(s), cap(s))
	s = append(s, 100)
	fmt.Printf("-----------追加后-------------\n")
	fmt.Println(len(s), cap(s))
	fmt.Println(s, a) // 重新分配底层数组，与原数组无关。
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

package main

import "fmt"

func main() {
	var a = []int{1, 2, 3}
	fmt.Printf("slice a : %v\n", a)
	s := a[:2:3] //s.cap=3
	fmt.Printf("slice s : %v\n", s)
	fmt.Println(len(s), cap(s))
	s = append(s, 100, 200) // 一次 append 两个值，超出 s.cap 限制。
	fmt.Printf("-----------追加后-------------\n")
	fmt.Println(len(s), cap(s))
	fmt.Println(s, a) // 重新分配底层数组，与原数组无关。
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

PS D:\phpstudy_pro\WWW\go\src\hello> go run test.go
slice a : [1 2 3]
slice s : [1 2]
2 3
-----------追加后-------------
4 6
[1 2 100 200] [1 2 3]
1
2
3
4
5
6
7

从输出结果可以看出，append 后的 s 重新分配了底层数组，并复制数据。如果只追加一个值，则不会超过 s.cap 限制，也就不会重新分配。若超出s.cap限制 通常以 2 倍容量重新分配底层数组。

切片拷贝

package main

import (
    "fmt"
)

func main() {

    s1 := []int{1, 2, 3, 4, 5}
    fmt.Printf("slice s1 : %v\n", s1)
    s2 := make([]int, 10)
    fmt.Printf("slice s2 : %v\n", s2)
    copy(s2, s1)
    fmt.Printf("copied slice s1 : %v\n", s1)
    fmt.Printf("copied slice s2 : %v\n", s2)
    s3 := []int{1, 2, 3}
    fmt.Printf("slice s3 : %v\n", s3)
    s3 = append(s3, s2...)
    fmt.Printf("appended slice s3 : %v\n", s3)
    s3 = append(s3, 4, 5, 6)
    fmt.Printf("last slice s3 : %v\n", s3)

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

slice遍历

package main

import (
	"fmt"
)

func main() {
	data := [...]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
	slice := data[:]
	for index, value := range slice {
		fmt.Printf("inde : %v , value : %v\n", index, value)
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13

可以看到，三个内存地址都不同，这也就验证了 Go 中数组赋值和函数传参都是值复制的。

指针

Go语言中的函数传参都是值拷贝，当我们想要修改某个变量的时候，我们可以创建一个指向该变量地址的指针变量。传递数据使用指针，而无须拷贝数据。Go语言中的指针操作非常简单，只需要记住两个符号：&（取地址）和*（根据地址取值)

指针地址和指针类型

每个变量在运行时都拥有一个地址，这个地址代表变量在内存中的位置。Go语言中使用&字符放在变量前面对变量进行“取地址”操作。 Go语言中的值类型（int、float、bool、string、array、struct）都有对应的指针类型，如：*int、*int64、*string等

取变量指针的语法如下：

 ptr := &v    // v的类型为T

 v:代表被取地址的变量，类型为T
 ptr:用于接收地址的变量，ptr的类型就为*T，称做T的指针类型。*代表指针。
1
2
3
4

func main() {
    a := 10
    b := &a
    fmt.Printf("a:%d ptr:%p\n", a, &a) // a:10 ptr:0xc00001a078
    fmt.Printf("b:%p type:%T\n", b, b) // b:0xc00001a078 type:*int
    fmt.Println(&b)                    // 0xc00000e018
}
1
2
3
4
5
6
7

指针取值

在对普通变量使用&操作符取地址后会获得这个变量的指针，然后可以对指针使用*操作，也就是指针取值。

func main() {
	//指针取值
	a := "老6"
	b := &a // 取变量a的地址，将指针保存到b中
	fmt.Printf("type of b:%T\n", b)
	c := *b // 指针取值（根据指针去内存取值）
	fmt.Printf("type of c:%T\n", c)
	fmt.Printf("value of c:%v\n", c)
}
1
2
3
4
5
6
7
8
9

type of b:*string
type of c:string
value of c:老6
1
2
3

总结： 取地址操作符&和取值操作符*是一对互补操作符，&取出地址，根据地址取出地址指向的值。
1.对变量进行取地址（&）操作，可以获得这个变量的指针变量。
2.指针变量的值是指针地址。
3.对指针变量进行取值（）操作，可以获得指针变量指向的原变量的值。

new & make

new

new函数不太常用，使用new函数得到的是一个类型的指针，并且该指针对应的值为该类型的零值。

func main() {
    a := new(int)
    b := new(bool)
    fmt.Printf("%T\n", a) // *int
    fmt.Printf("%T\n", b) // *bool
    fmt.Println(*a)       // 0
    fmt.Println(*b)       // false
}
1
2
3
4
5
6
7
8

注意：指针作为引用类型需要初始化后才会拥有内存空间，才可以给它赋值。所以需要使用内置的new函数进行初始化

make

make也是用于内存分配的，区别于new，它只用于slice、map以及chan的内存创建，而且它返回的类型就是这三个类型本身，而不是他们的指针类型，因为这三种类型就是引用类型，所以就没有必要返回他们的指针。

make函数是无可替代的，我们在使用slice、map以及channel的时候，都需要使用make进行初始化，然后才可以对它们进行操作。

make 和 new 的区别

1.二者都是用来做内存分配的。
2.make只用于slice、map以及channel的初始化，返回的还是这三个引用类型本身；
3.而new用于类型的内存分配，并且内存对应的值为类型零值，返回的是指向类型的指针。

Map

map是一种无序的基于key-value的数据结构，Go语言中的map是引用类型，必须初始化才能使用。

map[KeyType]ValueType

KeyType:表示键的类型。

ValueType:表示键对应的值的类型。
1
2
3
4
5

map类型的变量默认初始值为nil，需要使用make()函数来分配内存。语法为：

 make(map[KeyType]ValueType, [cap])
1

cap表示map的容量，该参数虽然不是必须的，但是我们应该在初始化map的时候就为其指定一个合适的容量

func main() {
    scoreMap := make(map[string]int, 8)
    scoreMap["张三"] = 90
    scoreMap["小明"] = 100
    userInfo := map[string]string{
        "username": "pprof.cn",
        "password": "123456",
    }
    fmt.Println(userInfo) 
    fmt.Println(scoreMap)
    fmt.Println(scoreMap["小明"])
    fmt.Printf("type of a:%T\n", scoreMap)
}
1
2
3
4
5
6
7
8
9
10
11
12
13

判断某个键是否存在

value, ok := map[key]
1

func main() {
	scoreMap := make(map[string]int)
	scoreMap["张三"] = 90
	scoreMap["小明"] = 100
	// 如果key存在ok为true,v为对应的值；不存在ok为false,v为值类型的零值
	v, ok := scoreMap["张三"]
	if ok {
		fmt.Println(v)
	} else {
		fmt.Println("查无此人")
	}
}
1
2
3
4
5
6
7
8
9
10
11
12

map的遍历

func main() {
	scoreMap := make(map[string]int)
	scoreMap["张三"] = 90
	scoreMap["小明"] = 100
	scoreMap["王五"] = 60
	for k, v := range scoreMap {
		fmt.Println(k, v)
	}
	//单独遍历k
	for k := range scoreMap {
		fmt.Println(k)
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13

delete()函数删除键值对

delete(map, key)

map:表示要删除键值对的map

key:表示要删除的键值对的键
1
2
3
4
5

func main() {
	scoreMap := make(map[string]int)
	scoreMap["张三"] = 90
	scoreMap["小明"] = 100
	scoreMap["王五"] = 60
	delete(scoreMap, "小明") //将小明:100从map中删除
	//单独遍历k
	for k := range scoreMap {
		fmt.Println(k)
	}
}
1
2
3
4
5
6
7
8
9
10
11