go语⾔之⾏--数组、切⽚、map ⼀、内置函数
append ：追加元素到slice⾥，返回修改后的slice
close ：关闭channel
delete ：从map中删除key对应的value
panic  ：⽤于异常处理，停⽌常规的goroutine
recover ：⽤于异常处理，允许程序定义goroutine的panic动作
imag ：返回复数(complex)的实部
real  ：返回复数(complex)的虚部
make :⽤来分配内存，主要分配引⽤类型，返回Type本⾝(只能应⽤于slice, map, channel)
new ：分配内存，主要分配值类型，返回指向Type的指针，如int
cap  ：容量，容积capacity
copy ：复制slice，返回复制的数⽬
len ：返回长度
⼆、数组与切⽚
概念：同⼀组数据类型的固定长度的序列
注意：
长度数数组类型的⼀部分，因此var a[2] int 和 var a[3] int是不同的类型
数组索引是从0开始(python相同)，访问超过了索引会panic
数组定义完成之后，每个位置会有默认值，int类型，默认值为0，string类型默认为空字符串
数组属于值类型，当对其进⾏拷贝并修改副本值时，并不会改变原来的值
定义⽅法：
//第⼀种
/
/var <；数组名称> [<；数组长度>]<；数组元素>
var arr [2]int
arr[0]=1
arr[1]=2
//第⼆种
var a []int
a = make([]int, 4)
//第三种
//var <；数组名称> = [<；数组长度>]<；数组元素>{元素1，元素2,...}
var arr = [2]int{1,2}
//或者
arr := [2]int{1,2}
//第四种
//var <；数组名称> [<；数组长度>]<；数组元素> = [...]<；元素类型>{元素1，元素2,...}
var arr = [...]int{1,2}
//或者
arr := [...]int{1,2}
//第五种
//var <；数组名称> [<；数组长度>]<；数组元素> = [...]<；元素类型>{索引1：元素1，索引2：元素2,...}
var arr = [...]int{1:1,0:2}
//或者
arr := [...]int{1:1,0:2}
数组遍历
package main
import "fmt"
func main()  {
var arr = [...] int {0:2,1:4,2:8}
for i := 0; i<len(arr); i++ {
fmt.Println(arr[i])
}
}//结果：2,4,8
package main
import "fmt"
func test(a *[3] int )  { //传递地址
(*a)[0]=100
return
}
func main()  {
var arr [3] int
test(&arr)          //使⽤&取地址
fmt.Println(arr[0])
}//结果：100
使⽤函数修改数组元素
package main
import (
"fmt"
)
func fab(n int) {
var a []int
a = make([]int, n)
a[0] = 1
a[1] = 1
for i := 2; i < n; i++ {
a[i] = a[i-1] + a[i-2]
}
for _, v := range a {
fmt.Println(v)
}
}
func main() {
fab(5)
}
斐波那契数列
多维数组
多维数组，相当于多添加了维数
package main
import "fmt"
func main() {
var a [5][4][3] int//三维数组
a[1][1][0]=1
a[1][0][0]=1
a[1][1][1]=1
fmt.Println(a)
}
切⽚
概念：切⽚是对数组的引⽤，数组的长度不便，但是切⽚长度是可以变化的。
切⽚的特性和数组⼀样，因此遍历、长度计算等和数组⼀样
切⽚定义和数组的定义⽅式在于是否有长度定义，有长度定义为数组、没有长度定义为切⽚
//⽅式⼀，使⽤make创建
slice1 := make([]type, len,capacity)  或者var slice1 []type = make([]type, len,capacity)//其中capacity(容量)为可选参数//⽅式⼆，直接初始化
slice2 :=[] int {1,2} //长度为2，容量为2
//⽅式三，从数组中获取切⽚，与python⼀样
slice3 := arr[startIndex:endIndex] //将arr数组中从下标startIndex到endIndex-1下的元素创建为⼀个新的切⽚
slice4 := arr[startIndex:]        //缺省endIndex时将表⽰⼀直到arr数组的最后⼀个元素
slice5 := arr[:endIndex]          //缺省startIndex时将表⽰从arr数组的第⼀个元素开始
切⽚操作
len：计算长度（长度是指已经被赋过值的最⼤下标+1）
cap：求容量（容量是指切⽚可容纳的最多元素个数）
copy: 拷贝切⽚
append：向切⽚中追加元素
注意事项：python 定义数组
使⽤append向切⽚追加元素，如果长度没超过定义的切⽚的长度，返回原来的切⽚地址，如果超过了长度，切⽚会扩容进⾏重新分配地址。
package main
import "fmt"
func main() {
var slice2 [] int = make([] int,2,3)
fmt.Println(len(slice2),cap(slice2))
}//结果 2，3
package main
import "fmt"
func main() {
var slice1 [] int = make([] int,2,3)
slice2 :=[] int {2,2,2}
fmt.Printf("%p--%d\n",slice1,slice1)
slice1=append(slice1,1)    //追加单个元素
fmt.Printf("slice1:%p--%d\n",slice1,slice1)
slice3 :=append() //追加另⼀个切⽚
fmt.Printf("slice3:%p--%d\n",slice3,slice3)
slice4 := make([] int,len(slice3))
copy(slice4,slice3)        //拷贝slice3
fmt.Printf("copy：slice3:%p--%d\n",slice3,slice3)
fmt.Printf("slice4:%p--%d\n",slice4,slice4)
}
空(nil)切⽚
⼀个切⽚在未初始化之前默认为 nil，长度为 0
三、map
概念：map是go语⾔内置key-value的数据结构，与python的dict类似，可称为字典或关联数组。
map声明与初始化
map属于引⽤类型，声明是不会分配内存的，需要make初始化分配内存。
/
/只声明不初始化，直接使⽤会panic，需要使⽤make分配内存后⽅可使⽤
var a map[keytype]valuetype
var a map[string]string
var a map[string]int
var a map[int]string
var a map[string]map[string]string　
//声明并初始化
var a map[string]string
a = make(map[string]string, 8) //8代表容量
a := make(map[string]string, 8)
a := make(map[string]string)
var a map[string]string = map[string]string{}
var a map[string]string =map[string]string{"name":"wd","age":"22"}
map嵌套
map可以嵌套，类似json格式，声明时候只需要将value改为map，同样使⽤之前需要初始化每⼀层的map，⽰例：
package main
import "fmt"
func main() {
a := make(map[string]map[string]string,10)  //⼆层map嵌套，声明外层map并初始化
a["key1"] = make(map[string]string) //初始化第⼆层map
a["key1"]["key2"] = "a1"
a["key1"]["key3"] = "b1"
a["key1"]["key4"] = "c1"
fmt.Println(a)
}
map操作
增删改查、求长度
mymap["name"] = "wd"// 创建或者更新
delete(mymap, "name")    // 删除
name := mymap["name"]    // 查询
len(mymap)  // 求长度
//测试key是否存在
package main
import "fmt"
func main() {
a := make(map[string]string,10)
a["key1"] = "wd"
val,ok := a["key1"]  //ok为true时，代表有key
if ok{
fmt.Println(val)
}else {
fmt.Println("key1 is not exist")
}
}
遍历map
package main
import (
"fmt"
)
func main() {
a := map[string]string{"NAME":"WD","AGE":"22"}
for k :=range a{  //使⽤key进⾏遍历
fmt.Println(a[k])
}
for k,v :=range a{    //使⽤key，value进⾏遍历
fmt.Println(k,v)
}
}
切⽚嵌套map
package main
import "fmt"
func main() {
a := map[string]string{"NAME":"WD","AGE":"22"} //初始化map
b := make([]map[string]string,3,3)  //初始化切⽚
b[0]=a
fmt.Println(b)
}
map排序
go语⾔中的map都是⽆序的，并且⽆内置排序⽅法，所有如果我们想要对map进⾏排序，我们需要⾃⼰实现。⽅法：
先获取所有的key，将key进⾏排序
按照排序好的key进⾏遍历
package main
import (
"fmt"
"sort"
)
func main() {
a:= map[string]string{"1":"a","2":"b","3":"c","4":"d"} var keys [] string
for k := range a{
keys = append(keys, k)
}
sort.Strings(keys)//排序切⽚key
fmt.Println(keys,len(keys))
for _,val := range keys{  //循环key取值
fmt.Println(a[val])
}
}

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。