Go学习第一天
数组
- 数组:是同一种数据类型的固定长度的序列。
- 数组定义:var a [len]int,比如:var a [5]int,数组长度必须是常量,且是类型的组成部分。一旦定义,长度不能变。
- 长度是数组类型的一部分,因此,var a[5] int和var a[10]int是不同的类型。
- 数组可以通过下标进行访问,下标是从0开始,最后一个元素下标是:len-1
- 访问越界,如果下标在数组合法范围之外,则触发访问越界,会panic
- 数组是值类型,赋值和传参会复制整个数组,而不是指针。因此改变副本的值,不会改变本身的值。
- 支持 “==”、“!=” 操作符,因为内存总是被初始化过的。
- 指针数组 [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)
}
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]
多维数组
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)
}
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]]
数组长度
内置函数 len 和 cap 都返回数组长度 (元素数量)。
package main
func main() {
a := [2]int{}
println(len(a), cap(a))
}
多维数组遍历
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()
}
}
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
切片
切片是指向数组的指针,对切片的操作,就是操作底层的数组。
- 切片:切片是数组的一个引用,因此切片是引用类型。但自身是结构体,值拷贝传递。
- 切片的长度可以改变,因此,切片是一个可变的数组。
- 切片遍历方式和数组一样,可以用len()求长度。表示可用元素数量,读写操作不能超过该限制。
- cap可以求出slice最大扩张容量,不能超出数组限制。0 <= len(slice) <= len(array),其中array是slice引用的数组。
- 切片的定义:var 变量名 []类型,比如 var str []string var arr []int。
- 如果 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)
}
PS D:\phpstudy_pro\WWW\go\src\hello> go run test.go
是空
[]
[]
[]
[1 2 3]
[2 3 4]
切片初始化
操作 | 含义 |
---|---|
s[n] | 切片s中索引位置 为 n 的项 |
s[:] | 切片s中索引位置 0 到 len(s)-1 处所获得的切片 |
s[start:] | 切片s中索引位置 start 到 len(s)-1 处所获得的切片 |
s[:end] | 切片s中索引位置 0 到 end 处所获得的切片 ,len=end |
s[start:end] | 切片s中索引位置 start 到 end 处所获得的切片 len=end-start |
s[start : end : max] | 切片s中索引位置 start 到 end 处所获得的切片 len=end-start cap=max-start |
len(s) | 切片s的长度 <=cap(s) |
cap(s) | 切片s的容量 >=len(s) |
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))
}
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
make创建切片
var slice []type = make([]type, len)
slice := make([]type, len)
slice := make([]type, len, cap)
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)
}
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]
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) // 重新分配底层数组,与原数组无关。
}
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) // 重新分配底层数组,与原数组无关。
}
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]
从输出结果可以看出,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)
}
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)
}
}
可以看到,三个内存地址都不同,这也就验证了 Go 中数组赋值和函数传参都是值复制的。
指针
Go语言中的函数传参都是值拷贝,当我们想要修改某个变量的时候,我们可以创建一个指向该变量地址的指针变量。传递数据使用指针,而无须拷贝数据。Go语言中的指针操作非常简单,只需要记住两个符号:&(取地址)和*(根据地址取值)
指针地址和指针类型
每个变量在运行时都拥有一个地址,这个地址代表变量在内存中的位置。Go语言中使用&字符放在变量前面对变量进行“取地址”操作。 Go语言中的值类型(int、float、bool、string、array、struct)都有对应的指针类型,如:*int、*int64、*string等
取变量指针的语法如下:
ptr := &v // v的类型为T
v:代表被取地址的变量,类型为T
ptr:用于接收地址的变量,ptr的类型就为*T,称做T的指针类型。*代表指针。
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
}
指针取值
在对普通变量使用&操作符取地址后会获得这个变量的指针,然后可以对指针使用*操作,也就是指针取值。
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)
}
type of b:*string
type of c:string
value of c:老6
总结: 取地址操作符&和取值操作符*是一对互补操作符,&取出地址,根据地址取出地址指向的值。
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
}
注意:指针作为引用类型需要初始化后才会拥有内存空间,才可以给它赋值。所以需要使用内置的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:表示键对应的值的类型。
map类型的变量默认初始值为nil,需要使用make()函数来分配内存。语法为:
make(map[KeyType]ValueType, [cap])
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)
}
判断某个键是否存在
value, ok := map[key]
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("查无此人")
}
}
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)
}
}
delete()函数删除键值对
delete(map, key)
map:表示要删除键值对的map
key:表示要删除的键值对的键
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)
}
}