Go基础数组切片Map

Posted 2021-09-03 justry_deng

数组、切片、Map

• 数组、切片、Map
  • 数组array
  • 切片slice
  • 键值对map
  • 相关资料

---

数组array

格式形如：

var variable_name [SIZE]variable_type

注：数组的长度是固定的

• 示例一：基操

import "fmt"

func main() {
	var arr [3]string = [3]string{"张三", "李四", "王五"}
	fmt.Println(arr) // 输出：[张三 李四 王五]
}

• 示例二：如果不赋值，那么值默认为"零"值

import "fmt"

func main() {
	var arr1 [3]int
	fmt.Println(arr1) // 输出：[0 0 0]
	// 字符串的"零"值为""
	var arr2 [3]string
	fmt.Println(arr2) // 输出：[  ]
	var arr3 [3]float64
	fmt.Println(arr3) // 输出：[0 0 0]
	var arr4 [3]bool
	fmt.Println(arr4) // 输出：[false false false]
}

• 示例三：:=也可以用

import "fmt"

func main() {
	v1 := [2]string{"邓沙利文", "JustryDeng"}
	fmt.Println(v1) // 输出：[邓沙利文 JustryDeng]
}

• 示例四：访问与赋值

import "fmt"

func main() {
	v1 := [2]string{"邓沙利文", "JustryDeng"}
	// 访问
	fmt.Println(v1[0]) // 输出：邓沙利文
	// 赋值
	v1[0] = "邓帅"
	fmt.Println(v1[0]) // 输出：邓帅
	fmt.Println(v1) // 输出：[邓帅 JustryDeng]
}

• 示例五：多维数组

import "fmt"

func main() {
	// 3行2列
	arr := [3][2]string{
		{"邓沙利文", "JustryDeng"},
		{"邓帅", "亨得帅"},
		{"美男子", "帅哥"},
	}
	// 全输出
	fmt.Println(arr) // 输出：[[邓沙利文 JustryDeng] [邓帅 亨得帅] [美男子 帅哥]]
	// 第一行
	fmt.Println(arr[0]) // 输出：[邓沙利文 JustryDeng]
	// 第二行
	fmt.Println(arr[1]) // 输出：[邓帅 亨得帅]
	// 第三行
	fmt.Println(arr[2]) // 输出：[美男子 帅哥]
	// 第三行第二列
	fmt.Println(arr[2][1]) // 输出：帅哥
}

• 示例六：循环遍历

import "fmt"

func main() {

	arr0 := [3]int{9527, 1888, 666}
	for i := 0; i < len(arr0); i++ {
		fmt.Println(arr0[i])
	}

	fmt.Println()

	arr1 := [3][2]string{
		{"邓沙利文", "JustryDeng"},
		{"邓帅", "亨得帅"},
		{"美男子", "帅哥"},
	}
	for i := 0; i < len(arr1); i++ {
		for j := 0; j < len(arr1[i]); j++ {
			fmt.Println(arr1[i][j])
		}
	}
}

输出

9527
1888
666

邓沙利文
JustryDeng
邓帅
亨得帅
美男子
帅哥

其它说明

• 遍历数组的方式还有很多，这里就不一一示例了

切片slice

简单的，可以将切片理解为动态数组（即：长度可变的数组）

• 获得方式

  1. 截取已有的数组或切片（里面的元素的内存地址共享）

     格式形如

     array|slice[startIndx:endIndex]

     • array代表数组
     • |代表或者
     • slice代表切片
     • startIndex代表截取开始位置（含startIndex）
       注：startIndex可省略，若startIndex省略，则代表从头开始截取
     • :此处代表至
     • endIndex代表截取结束位置（不含endIndex）
       注：endIndex可省略，若endIndex省略，则代表截取后面的全部

  2. 试用make函数构造切片

     格式形如

     make ([]T, length, capacity)

     • make 函数名
     • T切片内的元素类型
     • length长度
     • capacity容量（可省略，省略即表示capacity取值与length保持一致）

     提示：make 函数可构造的数据有很多，切片只是其中之一

• 和数组一样，切片内的元素初始值默认为”零“值

• 切片的常用方法

  1. len(slice)：计算切片的长度

  2. cap(slice)：计算切片的容量

  3. append(s1, T...)：往切片s1中追加元素，并返回新切片
     注：新切片与旧切片是独立的，修改互不干预

  4. copy(s2, s1)：将s1的内容拷贝到s2

     注：s1与s2是独立的，修改互不干预

  5. …

• 示例一：通过已有的数组获得切片

import "fmt"

func main() {
	arr := [5]int{1, 2, 3, 4, 5}
    // 截取数组arr以获得切片
	slice := arr[1:4]
	fmt.Println(slice) // 输出：[2 3 4]
}

• 示例二：只取数组（或切片）得到的切片，里面的元素地址与原数组（或切片）是共享的

import "fmt"func main() {	arr := [5]int{1, 2, 3, 4, 5}	slice := arr[1:4]	fmt.Println(slice) // 输出：[2 3 4]	fmt.Println(arr) // 输出：[1 2 3 4 5]	slice[0] = 100	arr[3] = 888	fmt.Println(slice) // 输出：[100 3 888]	fmt.Println(arr) // 输出：[1 100 3 888 5]}

• 示例三：通过make构造切片

import (	"fmt")func main() {	slice1 := make([]int, 1, 1)	slice1[0] = 100	fmt.Println(slice1) // 输出：[100]}

• 示例四：append获得新切片

import (	"fmt")func main() {	slice1 := make([]int, 1, 1)	slice1[0] = 100	fmt.Println(slice1) // 输出：[100]	// append	var slice2 []int = append(slice1, 123, 888)	fmt.Println(slice2) // 输出：[100 123 888]	// 他们的值互不影响	slice1[0] = -1	slice2[0] = -2	fmt.Println(slice1[0]) // 输出：-1	fmt.Println(slice2[0]) // 输出：-2}

• 示例五：copy切片

import (	"fmt")func main() {	slice1 := make([]int, 1, 1)	slice1[0] = 100	fmt.Println(slice1) // 输出：[100]	slice2 := make([]int, 1, 1)	fmt.Println(slice2) // 输出：[0]	// copy	copy(slice2, slice1)	fmt.Println(slice2) // 输出：[100]	// 他们的值互不影响	slice1[0] = -1	slice2[0] = -2	fmt.Println(slice1[0]) // 输出：-1	fmt.Println(slice2[0]) // 输出：-2}

键值对map

格式形如

var map_variable map[key_data_type]value_data_typemap_variable = make(map[key_data_type]value_data_type)// 或者map_variable := make(map[key_data_type]value_data_type)

• 从map中获取值时，支持以下方式接收返回值：

  • 一个返回值：值

    value = map[key]

  • 两个返回值：值, 键值对对是否存在

    value, existKeyValue = map[key]

示例一：map的存值、取值

import (	"fmt")func main() {	// 声明并构造map	myMap := make(map[string]string)	// 设置值	myMap["k1"] = "v1"	myMap["k2"] = "v2"	myMap["k3"] = "v3"	fmt.Println(myMap)	fmt.Println(myMap["k2"])	// 如果map中不存在对应的键值对，那么获取出来的为对应value_data_type类型的"零"值; 如下面这行代码获取到的就是string的零值，即空字符串""	fmt.Println(myMap["non-exist-key"])	myValue, hit := myMap["non-exist-key"]	if hit {		fmt.Println("myMap中存在key为non-exist-key的键值对, 对应的值为" + myValue)	} else {		fmt.Println("myMap中不存在key为non-exist-key的键值对")	}}

输出

map[k1:v1 k2:v2 k3:v3]v2myMap中不存在key为non-exist-key的键值对

• 示例二：遍历map，同时输出k-v

import (	"fmt")func main() {	// 声明并构造map	myMap := make(map[string]string)	// 设置值	myMap["k1"] = "v1"	myMap["k2"] = "v2"	myMap["k3"] = "v3"	// 遍历map	for k, v := range myMap {		fmt.Println(k, v)	}}

输出

k2 v2k3 v3k1 v1

注：range除了遍历map外，还能遍历其它数据结构，如：数组、切片等等

• 示例三：使用占位符_，不获取不需要的数据

import (
	"fmt"
)

func main() {
	// 声明并构造map
	myMap := make(map[string]string)
	// 设置值
	myMap["k1"] = "v1"
	myMap["k2"] = "v2"
	myMap["k3"] = "v3"

	// 遍历map, key的位置使用占位符_替代，表示不获取key
	for _, v := range myMap {
		fmt.Println(v)
	}

	fmt.Println()

	// 遍历map, value的位置使用占位符_替代，表示不获取value
	for k, _ := range myMap {
		fmt.Println(k)
	}
}

输出

v1
v2
v3

k1
k2
k3

---

^_^ 整理自《Go语言区块链应用开发从入门到精通》高野 编著

^_^ 本文已经被收录进《程序员成长笔记》 ，笔者JustryDeng