Golang 数组、切片、映射

定义数组

var arr1 [5]int   //整型类型
fmt.Println(arr1) //[0 0 0 0 0]
//赋值
arr1 = [5]int{1, 2, 3, 4, 5}
fmt.Println(arr1) //[1 2 3 4 5] var arr2 [6]*int //整型指针数组
fmt.Println(arr2) //[<nil> <nil> <nil> <nil> <nil> <nil>] var arr3 [2][3]int //二维数组
fmt.Println(arr3) //[[0 0 0] [0 0 0]] // 使用简短的格式
arr4 := [5]int{2, 4, 6, 8, 10}
fmt.Println(arr4) //[2 4 6 8 10] //其他方式,如果长度的位置是... 表示数组长度是根据后面的数据元素个数来计算
arr5 := [...]int{2, 3, 4, 5, 6, 7}
fmt.Println(arr5, len(arr5)) //[2 3 4 5 6 7] 6 // 指定数组的索引来赋值
arr6 := [...]int{5: 10, 7: 23}
//将数组下标为5的元素赋值为10,将数组下标为7的元素赋值为23
//数组长度为8
fmt.Println(arr6, len(arr6)) //[0 0 0 0 0 10 0 23] 8 arr7 := [2][3]int{{1, 2, 3}, {4, 5, 6}}
fmt.Println(arr7) //[[1 2 3] [4 5 6]]

  

数组访问与数组长度

arr1 := [5]int{2, 4, 6, 8, 10}
fmt.Println(arr1) // [2 4 6 8 10]
fmt.Println("length:", len(arr1)) //length: 5
// arr1[5] = 100 //出错,数组越界
arr1[0] = 99
fmt.Println(arr1) //[99 4 6 8 10] arr2 := [2][3]int{{1, 2, 3}, {4, 5, 6}}
fmt.Println(len(arr2)) //2
fmt.Println(len(arr2[0])) //3
fmt.Println(arr2[1][1]) //5

  

数组遍历

arr1 := [5]int{2, 4, 6, 8, 10}
for i := 0; i < len(arr1); i++ {
fmt.Println(arr1[i]) //2 4 6 8 10
}
for i, v := range arr1 {
fmt.Print(i, "=>", v) // 0=>2,1=>4,2=>6,3=>8,4=>10
}
// 不需要索引的时候,可以将用_代替i
for _, v := range arr1 {
fmt.Println(v) //2,4,6,8,10
}

  

数组作为函数参数

  数组作为函数作为参数时,如果是给形参传递数组名,那么就是传值操作,传递的是数组的副本,修改副本的内容,并不会影响实参。

  要想在函数中对数组的修改作用到实参,可以用数组指针,即->使用指针的形式,将数组的地址传递给函数,并且函数定义时,接收一个指针类型的参数,那么就可以对数组内部进行修改,但是不能修修改数组长度。

package main

import "fmt"

func Double(arr [5]int) [5]int {
for i := 0; i < 5; i++ {
arr[i] *= 2
}
return arr
} //接收的指针类型,即数组的地址
//注意这里的形参要写成 arr *[5]int 不要写成arr [5]*int
//arr [5]*int表示的是有五个元素的数组,每个元素是一个指针,即5个指针
//arr *[5]int表示的是一个指针,这一个指针指向一个拥有5个元素的数组,每个元素时一个int型变量
func Triple(arr *[5]int) {
for i := 0; i < 5; i++ {
arr[i] *= 3
}
}
func main() {
var arr2 [6]*int //整型指针数组
fmt.Println(arr2) //[<nil> <nil> <nil> <nil> <nil> <nil>]
arr := [5]int{1, 2, 3, 4, 5}
fmt.Println(arr) //[1 2 3 4 5] arr1 := Double(arr)
fmt.Println(arr1) //[2 4 6 8 10]
fmt.Println(arr) //[1 2 3 4 5] Triple(&arr)
fmt.Println(arr) //[3 6 9 12 15]
}

  

数组类型、数组比较

  数组的长度一旦确定,就不能再改变。如果要改变,只能转换为slice,但是用了slice之后,改变的是slice的长度,但是数组长度始终不变。

  数组长度不同,那么数组就不是同一个类型,不能相互赋值-->参数传递。

  相同类型的数组可以进行比较,这里的类型不只是数组元素的类型,也包括数组的长度都要相同,才能进行比较。

package main
import "fmt"
func Double(arr [5]int) [5]int {
for i := 0; i < 5; i++ {
arr[i] *= 2
}
return arr
} func main() {
arr1 := [5]int{1, 2, 3, 4, 5}
Double(arr1) //正确 形参和实参都是[5]int类型,注意[5]int是一个类型 arr2 := [6]int{1, 2, 3, 4, 5, 6}
Double(arr2) //错误,不能将类型为[6]int的实参,赋值给类型为[5]int的形参
//[5]int和[6]int是两个不同的类型
}

  

  

创建切片

var slice []int
//定义一个空切片,注意上面[]中没有指定长度,如果指定长度,就代表是数组了
fmt.Println(slice) //[] slice1 := []int{1, 2, 3, 4, 5}
//创建一个长度和容量为5的切片
fmt.Println(slice1) //[1 2 3 4 5]
fmt.Println(len(slice1), cap(slice1)) //5 5 slice2 := []int{5: 10}
//创建一个长度和容量为6的切片
fmt.Println(slice2) //[0 0 0 0 0 10]
fmt.Println(len(slice2), cap(slice2)) //6 6 //使用make创建切边
//make(type,len,cap),未指定cap是,cap和len相等
slice3 := make([]int, 5, 10)
fmt.Println(slice3, len(slice3), cap(slice3)) //[0 0 0 0 0] 5 10
slice4 := make([]int, 6)
fmt.Println(slice4, len(slice4), cap(slice4)) //[0 0 0 0 0 0] 6 6 // 利用数组创建切片
//[strat:end]左闭右开,start省略时,默认为0;end省略时默认为数组或者切片长度
arr := [10]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
slice5 := arr[3:]
fmt.Println(slice5) //[3 4 5 6 7 8 9] slice6 := arr[:7]
fmt.Println(slice6) //[0 1 2 3 4 5 6] slice7 := arr[4:8]
fmt.Println(slice7) //[4 5 6 7] slice8 := arr[:]
fmt.Println(slice8) //[0 1 2 3 4 5 6 7 8 9]

  通过len函数求的切片长度,判断是否为空。

append函数

  使用append函数后,返回的是一个slice类型,不是数组类型

slice := []int{1, 2, 3, 4, 5}
fmt.Println(slice) //[1 2 3 4 5] //追加元素
slice = append(slice, 6)
fmt.Println(slice) //[1 2 3 4 5 6] //追加切片
s1 := []int{99, 100}
//注意下面的...表示解构,即,将切片的内容展开后填充到该位置
slice = append(slice, s1...)
fmt.Println(slice)

  不能对数组调用append函数,即,append函数的第一个参数必须是slice。

copy函数

  copy(destination,resource),复制之后,dest的长度并不会改变,即使复制给他的切片长度远大于它。

//长的slice复制到短的slice
s1 := []int{1, 2, 3, 4, 5}
s2 := []int{10, 20, 30, 40}
copy(s2, s1)
fmt.Println(s2) //[1 2 3 4] //短的slice复制到长的slice
s3 := []int{2, 3, 4}
s4 := []int{9, 8, 7, 6, 5}
copy(s4, s3)
fmt.Println(s4) //[2 3 4 6 5] //相同长度的slice进行复制
s5 := []int{1, 2, 3}
s6 := []int{4, 5, 6}
copy(s6, s5)
fmt.Println(s6) //[1 2 3]

  不能使用copy进行数组的复制操作,即,copy的两个参数都必须是slice。

slice作为函数参数

  将数组传递给函数之后,在函数中操作的是数组的副本。虽然可以使用数组指针形式传递,但是更通用的是使用slice,使用slice之后,可以通过在函数中修改slice,来达到修改数组的目的。

package main

import "fmt"

//参数是数组类型
func Double(arr [5]int) {
for i := 0; i < 5; i++ {
arr[i] *= 2
}
} //类型是slice类型
func Triple(slice []int) {
for i := 0; i < len(slice); i++ {
slice[i] *= 3
}
}
func main() {
arr := [5]int{1, 2, 3, 4, 5}
Double(arr)
fmt.Println(arr) //[1 2 3 4 5] //数组转换为切片
slice := arr[:]
Triple(slice)
fmt.Println(arr) //[3 6 9 12 15]
}

  

创建map

//定义空的映射,默认值为nil
var m1 map[int]string
fmt.Println(m1) //map[]
//再进行初始化
m1 = map[int]string{
1: "hello",
8: "world", //注意这种写法,末尾的逗号不可省
}
fmt.Println(m1) //map[1:hello 8:world] //使用make创建映射,注意此时最多只用两个参数,
//一个是map的映射类型,一个map的容量,容量可以省略
//但是没有len这一个参数,即不能指定长度这一项
m2 := make(map[int]string, 100)
fmt.Println(m2, len(m2)) m3 := make(map[string][]string)
m3["server"] = []string{"apache", "nginx"}
m3["language"] = []string{"php", "golang", "python"}
fmt.Println(m3) //map[server:[apache nginx] language:[php golang python]] //创建映射,同时初始化,此时不需要使用make
m4 := map[int]string{1: "demo", 2: "test"}
fmt.Println(m4) //map[1:demo 2:test]

  

删除map元素

//字符串映射到string类型的切片
m1 := map[string][]string{
"server": []string{"apache", "nginx"},
"language": []string{"php", "python", "golang"},
}
fmt.Println(m1) //map[server:[apache nginx] language:[php python golang]] //删除没有的key,不报错
delete(m1, "client")
fmt.Println(m1) //map[server:[apache nginx] language:[php python golang]] delete(m1, "server")
fmt.Println(m1) //map[language:[php python golang]]

  

查找map元素

//字符串映射到string类型的切片
m1 := map[string][]string{
"server": []string{"apache", "nginx"},
"language": []string{"php", "python", "golang"},
}
fmt.Println(m1) //map[server:[apache nginx] language:[php python golang]] //访问一个不存在的元素,不会报错,返回类型零值
fmt.Println(m1["client"]) //[] v, exists := m1["client"]
fmt.Println(v, exists) //[] false v, exists = m1["server"]
fmt.Println(v, exists) //[apache nginx] true

  

遍历map

//字符串映射到string类型的切片
m1 := map[string][]string{
"server": []string{"apache", "nginx"},
"language": []string{"php", "python", "golang"},
}
for key, value := range m1 {
fmt.Println(key, "=>", value)
}
//server => [apache nginx]
//language => [php python golang]

  映射是无序的,所以遍历多次的结果,元素的顺序不一定完全相同

map注意事项

  1、map之间不能进行比较,但是可以和nil进行比较

  2、不能对map取地址,因为map本就是引用类型

var m0 map[int]string
fmt.Println(m0 == nil) //true var m1 map[int]string
fmt.Println(m0 == m1) //不能进行比较,会报错 m2 := map[int]string{1: "one", 2: "two"}
fmt.Println(m2 == nil) //false

  

map作为函数参数

package main

import "fmt"

//接受一个map
func Show(m map[int]string) {
m[1] = "three"
m[3] = "four"
}
func main() {
m1 := map[int]string{
1: "one",
2: "two",
}
fmt.Println(m1) //map[1:one 2:two] Show(m1)
fmt.Println(m1) //map[3:four 1:three 2:two]
}

  将map作为函数的参数,在函数中修改map,会直接影响到实参,因为map是引用类型。

  

上一篇:Linux-Nginx+rtmp+ffmpeg搭建流媒体服务器


下一篇:使用nginx+nginx-rtmp-module+ffmpeg搭建流媒体服务器