Go语言学习三:Go基础(iota,array,slice,map,make,new)
最后更新于：2022-04-01 11:58:56
# 分组声明
~~~
import "fmt"
import "os"
const i = 100
const ii = 3.1415
const iii = "test"
var i int
var ii float64
var iii string
//分组代码如下
import(
"fmt"
"os"
)
const(
i = 1
ii = 3.1415
iii = "test"
)
var (
i int
ii float64
iii string
)
~~~
# iota枚举
这个关键字用来声明enum的时候用，它默认开始值是0，每调用一次+1.
~~~
package main
import "fmt"
const (
x = iota
y = iota
z = iota
w
)
const v = iota //每遇到const关键字，iota就会重置
func main() {
fmt.Printf("x=%d\ny=%d\nz=%d\nw=%d\nv=%d", x, y, z, w, v)
}
~~~
**大写字母开头的变量是可导出的，即其他包可以读取，是公用变量**
**小写字母开头的不可导出，是私有变量**
**大写字母开头的函数也一样，相当于class中带public关键字词的公有函数**
**小写字母开头的函数，就是有private关键词的私有函数**
# array数组
在[n]array中，
n表示数组的长度
type表示存储元素的类型
~~~
var arr [n]array
~~~
~~~
package main
import "fmt"
func main() {
var arr [5]int //声明了一个int类型的数值
arr[0] = 10
arr[4] = 20
fmt.Printf("This first is %d\n", arr[0])
fmt.Printf("This last is %d\n", arr[4])
}
~~~
说明：长度也是数组类型的一部分，因此[5]int与[10]int是不同的类型，数组也就不能改变长度。
如果使用指针，就需要用到slice类型
~~~
package main
import "fmt"
func main() {
a := [5]int{1,2,3,4,5} //声明了一个长度为5的int数组
b := [...]int{7,8,9} //可以省略长度，`...`的方式，会自动根据元素个数来计算长度
c := [2][4]int{1,2,3,4},{5,6,7,9} //声明了一个二维数组，两个数组作为元素，每个数组中又有4个int类型的元素
}
~~~
# slice
在初始定义数组时，我们并不知道需要多大的数组，因此我们就需要“动态数组”，这种数据结构叫slice。
slice并不是真正意义上的动态数组，而是一个引用类型。
slice总是指向一个底层array
~~~
//声明和array一样，只是少了长度
var a []int
~~~
slice通过 array[i:j]来获取，其中i是数组的开始位置,j是结束为止，但不包含array[j]，
~~~
//声明一个含有5个元素类型为byte的数组
test := [5]byte{'a', 'b', 'c', 'd', 'e'}
//声明两个含有byte的slice
var a, b []byte
a = test[1:3] //test[1],test[2]
b = test[3:5] //test[3],test[4]
~~~
1、slice的默认开始位置0，test[:n]等价于test[0:n]
2、slice的第二个序列默认是数组的长度，test[n:] 等价于 test[n:len[test]]
3、如果直接获取slice,可以使用test[:]
# map
map读取和设置也类似slice一样，通过key来操作，只是slice的index只能是int类型，而map多了很多类型，可以是int,string及所有完全定义了 == 与 != 操作的类型。
~~~
package main
import "fmt"
func main() {
//声明一个key是字符串，值为int的字典，这种声明需要在使用之前使用make初始化
//var numbers map[string]int
//另一种map的声明方式
numbers := make(map[string]int)
numbers["test"] = 1
numbers["test1"] = 2
numbers["test2"] = 3
fmt.Println("test2:", numbers["test2"])
}
~~~
### map的初始化
可以通过key:val的方式初始化值，同时map内置有判断是否存在key的方式
~~~
package main
import "fmt"
func main() {
//初始化一个字典
test := map[string]float32{"a": 1, "b": 2, "c": 3}
//map有两个返回值，第二个返回值,如果不存在key返回flase,如果存在key返回true
testArr, result := test["a"]
if result {
fmt.Println("value:", testArr)
} else {
fmt.Println("key不存在")
}
}
~~~
### 通过delete删除map元素
~~~
delete(testArr,"a") //删除key为a的元素
~~~
### map是一种引用类型
如果两个map同时指向一个底层，那么一个改变，另一个也相应改变
~~~
package main
import "fmt"
func main() {
m := make(map[string]string)
m["test"] = "test"
m1 := m
m1["test"] = "change test" //现在,m["test"]的值也已经是chage test了
fmt.Printf("改变后的test:%s", m["test"])
}
~~~
# make,new操作
### make
make用于内建类型(map、slice、channel)的内存分配
make(T,args)与new(T)有着不同的功能，make只能创建slice,map,channel，并且返回一个有初始值(非零)的T类型，而不是*T
### new
new用于各种类型的内存分配【new返回指针】
new(T)分配了零值填充的T类型的内存空间，并且返回其地址，即一个*T类型的值(GO语言的术语：返回了一个指针，指向新分配的类型T的零值)
**总结：**
new 负责分配内存，new(T) 返回*T 指向一个零值 T 的指针
make 负责初始化值，make(T) 返回初始化后的 T ，而非指针
最重要的一点：make 仅适用于slice，map 和channel
关于“零值”，并非是空值，而是一种“变量未填充前”的默认值，通常为0，如下
~~~
int 0
int8 0
int32 0
int64 0
uint 0x0
rune 0 //rune的实际类型是 int32
byte 0x0 //byte的实际类型是uint8
float32 0 //长度为4 byte
float64 0 //长度为8 byte
bool false
string ""
~~~