go语言之行--数组、切片、map

发布时间：2020-12-16 19:34:50 所属栏目：大数据来源：网络整理

导读：一、内置函数 append ：追加元素到slice里,返回修改后的slice close ：关闭channel delete ：从map中删除key对应的value panic? ：用于异常处理，停止常规的goroutine recover ：用于异常处理，允许程序定义goroutine的panic动作 imag ：返回复数(complex)

一、内置函数

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类型默认为空字符串
数组属于值类型，当对其进行拷贝并修改副本值时，并不会改变原来的值

定义方法：

[<数组长度>]<数组元素> arr []]=]=

//第二种
var a []int
a = make([]int,4)

//第三种
//var <数组名称> = [<数组长度>]<数组元素>{元素1,元素2,...}
var arr = [2]int{1,2}
//或者
arr := [2]int{1,2}

//第四种
//var <数组名称> [<数组长度>]<数组元素> = [...]<元素类型>{元素1,...}
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}

数组遍历

import "fmt"

func main() {
var arr = [...] int {0:2,1:4,2:8}

</span><span style="color: #0000ff;"&gt;for</span> i := <span style="color: #800080;"&gt;0</span>; i<len(arr); i++<span style="color: #000000;"&gt; {
    fmt.Println(arr[i])
}


}</span><span style="color: #008000;"&gt;//</span><span style="color: #008000;"&gt;结果：2,4,8</span></pre>

import "fmt"

func test(a [3] int ) { //传递地址
(a)[0]=100
return
}

func main() {
var arr [3] int
test(&arr) //使用&取地址
fmt.Println(arr[0])

}</span><span style="color: #008000;"&gt;//</span><span style="color: #008000;"&gt;结果：100</span></pre>

import (
"fmt"
)

func fab(n int) {
var a []int
a = make([]int,n)

a[</span><span style="color: #800080;"&gt;0</span>] = <span style="color: #800080;"&gt;1</span><span style="color: #000000;"&gt;
a[</span><span style="color: #800080;"&gt;1</span>] = <span style="color: #800080;"&gt;1</span>

<span style="color: #0000ff;"&gt;for</span> i := <span style="color: #800080;"&gt;2</span>; i < n; i++<span style="color: #000000;"&gt; {
    a[i] </span>= a[i-<span style="color: #800080;"&gt;1</span>] + a[i-<span style="color: #800080;"&gt;2</span><span style="color: #000000;"&gt;]
}
</span><span style="color: #0000ff;"&gt;for</span> _,v :=<span style="color: #000000;"&gt; range a {
    fmt.Println(v)
}

}

func main() {
fab(5)
}

多维数组

多维数组，相当于多添加了维数

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)
}

切片

概念：切片是对数组的引用，数组的长度不便，但是切片长度是可以变化的。

切片的特性和数组一样，因此遍历、长度计算等和数组一样

切片定义和数组的定义方式在于是否有长度定义，有长度定义为数组、没有长度定义为切片

slice1 := make([]type,len,capacity) 或者var slice1 []type = make([]type,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：向切片中追加元素

注意事项：

使用append向切片追加元素，如果长度没超过定义的切片的长度，返回原来的切片地址，如果超过了长度，切片会扩容进行重新分配地址。

import "fmt"

func main() {
var slice2 [] int = make([] int,2,3)
fmt.Println(len(slice2),cap(slice2))

}//结果 2，3

import "fmt"

func main() {
var slice1 [] int = make([] int,3)
slice2 :=[] int {2,2}

fmt.Printf(</span><span style="color: #800000;"&gt;"</span><span style="color: #800000;"&gt;%p--%dn</span><span style="color: #800000;"&gt;"</span><span style="color: #000000;"&gt;,slice1,slice1)
slice1</span>=append(slice1,<span style="color: #800080;"&gt;1</span>)    <span style="color: #008000;"&gt;//</span><span style="color: #008000;"&gt;追加单个元素</span>
fmt.Printf(<span style="color: #800000;"&gt;"</span><span style="color: #800000;"&gt;slice1:%p--%dn</span><span style="color: #800000;"&gt;"</span><span style="color: #000000;"&gt;,slice1)
slice3 :</span>=append(slice1,slice2...) <span style="color: #008000;"&gt;//</span><span style="color: #008000;"&gt;追加另一个切片</span>
fmt.Printf(<span style="color: #800000;"&gt;"</span><span style="color: #800000;"&gt;slice3:%p--%dn</span><span style="color: #800000;"&gt;"</span><span style="color: #000000;"&gt;,slice3,slice3)
slice4 :</span>= make([] <span style="color: #0000ff;"&gt;int</span><span style="color: #000000;"&gt;,len(slice3))
copy(slice4,slice3)         </span><span style="color: #008000;"&gt;//</span><span style="color: #008000;"&gt;拷贝slice3</span>
fmt.Printf(<span style="color: #800000;"&gt;"</span><span style="color: #800000;"&gt;copy：slice3:%p--%dn</span><span style="color: #800000;"&gt;"</span><span style="color: #000000;"&gt;,slice3)
fmt.Printf(</span><span style="color: #800000;"&gt;"</span><span style="color: #800000;"&gt;slice4:%p--%dn</span><span style="color: #800000;"&gt;"</span><span style="color: #000000;"&gt;,slice4,slice4)

}

空(nil)切片

一个切片在未初始化之前默认为 nil，长度为 0

三、map

概念：map是go语言内置key-value的数据结构，与python的dict类似，可称为字典或关联数组。

map声明与初始化

map属于引用类型，声明是不会分配内存的，需要make初始化分配内存。

a map[] a map[] a map[] a map[]map[]　

//声明并初始化
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，示例：

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[] = delete(mymap,) name := 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

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

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进行遍历

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])
}
}

（编辑：李大同）

【声明】本站内容均来自网络，其相关言论仅代表作者个人观点，不代表本站立场。若无意侵犯到您的权利，请及时与联系站长删除相关内容!