1 数组和切片、2 可变长参数 、3 maps

• 1 数组和切片
  • 1.1 数组
  • 1.2 切片
• 2 可变长参数
• 3 maps

1 数组和切片

1.1 数组

# 1 定义，初始化，使用
# 2 数组是值类型
	-数字，字符串，布尔，数组，都是值类型，真正直接存数据
    -切片，map，指针  引用类型，是个地址，指向了具体的值
    
# 3数组长度
# 4 循环打印数组
# 5 多纬数组
# 6 数组定义并赋初值  ,把第99 赋值为1 ，其他都是0

package main

import "fmt"

// 1 数组是值类型，go语言中函数传参是 copy 传递，复制一份参数，传入  当参数传递，在函数中修改，不会影响原来的
//2 数组长度

func main() {
	//1 数组是值类型
	//var a [3]int = [3]int{3, 4, 4}
	//test(a)
	//fmt.Println("外面的", a) // 会不会影响？

	// 2 数组长度
	//var a =[3]int{1,2,3}
	//a :=[3]int{1,2,3}
	//a := [...]int{3, 4, 5, 4, 5, 6, 67}
	//fmt.Println(a)
	//fmt.Printf("%T\n", a)
	//fmt.Println(len(a))

	// 3 循环打印数组
	//a := [...]int{3, 4, 5, 4, 5, 6, 67}
	// 基于索引的
	//for i := 0; i < len(a); i++ {
	//	fmt.Println(a[i])
	//}
	// range 循环，基于迭代的
	//for i,_ := range a { // i是索引，v是值
	//	fmt.Println(i)
	//	//fmt.Println(v)
	//}

	// 4 多纬数组
	//var a [3][2]int
	//var a [3][2]int = [3][2]int{{2, 2}, {3, 4}}
	//fmt.Println(a)
	//fmt.Println(a[0])
	//fmt.Println(a[0][1])
	// 循环多维数组
	//for i := 0; i < len(a); i++ {
	//	for j := 0; j < len(a[i]); j++ {
	//		fmt.Println(a[i][j])
	//	}
	//}
	//for _, v := range a {
	//	for _, v1 := range v {
	//		fmt.Println(v1)
	//	}
	//}

	// 5 数组定义并赋初值  ,把第99 赋值为1 ，其他都是0
	//var a [100]int8 = [100]int8{98: 1, 66: 88}
	//fmt.Println(a)

}

func test(a [3]int) {
	a[0] = 999
	fmt.Println(a)

}

1.2 切片

# slice:切片是由数组建立的一种方便、灵活且功能强大的包装。切片本身不拥有任何数据。它们只是对现有数组的【引用】

package main

import "fmt"

// 切片

func main() {

	//1 切片的定义   中括号中不放任何东西，是切片类型，放个数子，就是数组类型
	//var a []int //只定义，没有初始化，是引用类型  是nil类型，等同于python中的None
	//if a == nil {
	//	fmt.Println("我是空")
	//}
	//fmt.Println(a) // []
	//fmt.Println(a[0])
	// 1.1 定义并初始化
	//var b [10]int      //值类型，有默认值
	//var a []int = b[:] // 表示a这个切片，对数组进行引用，引用了从0到最后
	//fmt.Println(a)
	//a[8] = 88
	//fmt.Println(a[8])
	//fmt.Println(a)
	//
	//fmt.Println(b)

	// 2 切片的取值赋值
	//fmt.Println(a[8])

	// 3 切片的修改，会影响底层数组； 数组的修改也会影响切片
	//b[0] = 11
	//fmt.Println(b)
	//fmt.Println(a)

	// 4 基于数组，获得切片
	//var b [10]int = [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 0} //值类型，有默认值
	////var a []int = b[0:3]                                  // 表示a这个切片，对数组进行引用，引用了从0到最后
	////fmt.Println(a)
	////a[0] = 99
	////fmt.Println(a)
	////fmt.Println(b)
	//var a []int = b[6:9]
	//fmt.Println(a)
	//a[0] = 99
	//fmt.Println(a)
	//fmt.Println(b)
	//b[0] = 88
	//fmt.Println(b)

	// 5 切片追加值
	//var b [10]int = [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 0}
	//var a []int = b[6:9]
	//a[0] = 99
	//fmt.Println(b) //[1 2 3 4 5 6 99 8 9 0]
	//fmt.Println(a) //[99 8 9]
	//
	//a = append(a, 66)
	//fmt.Println(a) //[99 8 9 66]
	//fmt.Println(b) //[1 2 3 4 5 6 99 8 9 66]

	// 6  切片的长度和容量
	//var b [10]int = [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 0}
	//var a []int = b[6:9]
	//fmt.Println(len(a)) // 3
	//fmt.Println(cap(a)) //容量，能存多少 4 ,不是底层数组的大小，取决于切片切数组的位置

	// 7 切片如果追加值超过了底层数组长度，会自动扩容
	//var b [10]int = [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 0}
	//var a []int = b[6:9]
	//a[0] = 99
	//fmt.Println(b) //[1 2 3 4 5 6 99 8 9 0]
	//fmt.Println(a) //[99 8 9]

	//a = append(a, 66)
	//fmt.Println(a) //[99 8 9 66]
	//fmt.Println(b) //[1 2 3 4 5 6 99 8 9 66]
	//fmt.Println(len(a))
	//fmt.Println(cap(a))

	// 超过底层数组，追加值
	//a = append(a, 77)
	//fmt.Println(a)      //[99 8 9 66 77]
	//fmt.Println(len(a)) // 5
	//fmt.Println(cap(a)) // 8   ,超过容量，翻倍扩容（容量在1024内）
	//a = append(a, 11, 222, 33, 55)
	//fmt.Println(len(a)) // 9
	//fmt.Println(cap(a)) // 16   ,超过容量，翻倍扩容（容量在1024内）

	// 改底层数组
	//b[9] = 999
	//fmt.Println(b)
	//fmt.Println(a)

	// 8 切片定义并初始化  使用数组初始化
	// 使用make初始化
	//var a []int // 是 nil，没有初始化
	//var a []int = make([]int, 3, 4) // 要初始化 ,长度为3，容量为4
	//fmt.Println(a)                  // [0 0 0]
	//fmt.Println(len(a))
	//fmt.Println(cap(a))
	//var a []int = make([]int, 0, 4) // 要初始化 ,长度为0，容量为4
	//fmt.Println(a) // []    有可能是nil，有可能已经初始化完成了，只有初始化完成了才能用
	//fmt.Println(len(a))
	//fmt.Println(cap(a))

	//a = append(a, 5)
	//fmt.Println(a)
	//fmt.Println(len(a)) //1
	//fmt.Println(cap(a)) // 4

	// 9 切片的参数传递  引用类型，函数中修改值，会影响原来的
	//var a []int = make([]int, 3, 5)
	////a[1] = 99 //[0 99 0]
	//test2(a)
	//fmt.Println(a) // [99 0 0]

	// 10 多纬切片   切片定义并初始
	//var a []int = []int{2, 3, 4, 45}
	//fmt.Println(a)
	//fmt.Println(len(a))
	//fmt.Println(cap(a))
	//a = append(a, 55)
	//fmt.Println(len(a))
	//fmt.Println(cap(a))

	//var a [][]string = [][]string{{"1", "3"}, {"o"}, {"5", "o", "99"}}
	//fmt.Println(a)

	var a [][]string = make([][]string, 3, 3)
	fmt.Println(a[2])
	a[2] = make([]string, 3, 3)
	fmt.Println(a[2][0])

}

func test2(a []int) {
	a[0] = 99
	//fmt.Println(a) //[99 99 0]
	a = append(a, 33)
	a[0] = 88
	fmt.Println(a)

}

2 可变长参数

package main

import "fmt"

// 可变长参数

func main() {
	//test3("1", "lqz")
	var a []string = []string{"lqqz", "pyy"}
	test3(a...) // 相当于大散了传入
}

func test3(a ...string) {
	fmt.Println(a)
	fmt.Printf("%T", a)
	fmt.Println(cap(a))

}

3 maps

package main

import "fmt"

//map

func main() {

	//1 key -value 形式存储 定义一个map
	//var userInfo map[int]string // 没有初始化，它是nil，但是打印出来不是nil
	//fmt.Println(userInfo)       //map[]
	//if userInfo == nil {
	//	fmt.Println("asdfasdf")
	//}

	// 2 map 初始化 方式一
	//var userInfo map[int]string = map[int]string{1: "lqz", 3: "pyy"}
	//fmt.Println(userInfo)
	//if userInfo == nil {
	//	fmt.Println("asdfasdf")
	//}

	// 2 map 初始化 方式二  make初始化
	//var userInfo map[int]string = make(map[int]string)
	//fmt.Println(userInfo) //map[]
	//if userInfo == nil {
	//	fmt.Println("asdfasdf")
	//}

	// 3 初始化后才能取值赋值
	//var userInfo map[int]string = make(map[int]string)
	//var userInfo map[int]string
	////fmt.Println(userInfo[1])
	//userInfo[1] = "pyy"
	//fmt.Println(userInfo)

	// 以后所有的引用类型，都需要初始化才能用，值类型不需要，有默认值

	//4 取值赋值
	//var userInfo map[string]string = make(map[string]string)
	//userInfo["age"] = "19"
	//userInfo["name"] = "lqz"
	//fmt.Println(userInfo)
	//
	//fmt.Println(userInfo["age"])
	//// 取不存在的----》显示vaule值的默认值
	//fmt.Println("--", userInfo["hobby"])
	//
	//// 如何判断一个key在不在map中   按key取值，能返回一个布尔值,根据布尔值判断
	//v, ok := userInfo["name"]
	//fmt.Println(v)
	//fmt.Println(ok) //false
	//
	//if v, ok := userInfo["name"]; ok {
	//	fmt.Println(v)
	//}

	// 5 删除map元素
	//var userInfo map[string]string = make(map[string]string)
	//userInfo["age"] = "19"
	//userInfo["name"] = "lqz"
	//delete(userInfo, "name")
	//fmt.Println(userInfo)

	// 6 map的长度
	//var userInfo map[string]string = make(map[string]string)
	//fmt.Println(len(userInfo))
	//userInfo["age"] = "19"
	//userInfo["name"] = "lqz"
	//fmt.Println(len(userInfo))

	// 7 引用类型
	var userInfo map[string]string = make(map[string]string)
	fmt.Println(len(userInfo))
	userInfo["age"] = "19"
	userInfo["name"] = "lqz"
	test6(userInfo)
	fmt.Println(userInfo)

}
func test6(u map[string]string) {
	u["name"] = "pyy"
	fmt.Println(u)

}