Golang学习历程【第六篇 复合数据类型map&函数初识】
- 1. Map数据类型
- 1.1. Map声明和初始化
- 1.2. Map 遍历
- 1.3 Map增删改查
- 2. function (函数)
- 2.1 函数各种定义方式
1. Map数据类型
Map结构是键值对的集合，其中每个键都是唯一的，并且每个键都映射到一个值。
Map是无序的，即元素的顺序是不确定的。
Map的初始值是nil，不能直接使用，需要使用make函数来创建一个Map。
Map结构为引用数据类型
1.1. Map声明和初始化
// Map的声明,其中keyType是键的类型，valueType是值的类型
// 1. 先声明 var 变量名 map[keyType]valueType
var map1 map[string]int
// 2. 使用make函数来创建一个Map
map1 = make(map[string]int)
map1["a"] = 1
map1["b"] = 2
map1["c"] = 3
// 2. 声明即创建 ,并赋值 var 变量名 = make(map[keyType]valueType)
var map2 = make(map[string]int)
map2["a"] = 4
map2["b"] = 5
map2["c"] = 6
// 3. 简短声明 变量名 := map[keyType]valueType
map3 := map[string]int{}
map3["a"] = 7
map3["b"] = 8
map3["c"] = 9
// 4. 声明即创建,并赋值
var map4 = map[string]int{"a": 10, "b": 11, "c": 12}
// 5. 简短声明,并赋值
map5 := map[string]int{"a": 13, "b": 14, "c": 15}
// 6. 声明一个map和定义一个map,其值的区别
var map6 map[string]int
var map7 = map[string]int{}
fmt.Printf("map1 类型：%T 值：%v map1 是否为 nil %v \n", map1, map1, map1 == nil)
fmt.Printf("map2 类型：%T 值：%v map2 是否为 nil %v \n", map2, map2, map2 == nil)
fmt.Printf("map3 类型：%T 值：%v map3 是否为 nil %v \n", map3, map3, map3 == nil)
fmt.Printf("map4 类型：%T 值：%v map4 是否为 nil %v \n", map4, map4, map4 == nil)
fmt.Printf("map5 类型：%T 值：%v map5 是否为 nil %v \n", map5, map5, map5 == nil)
fmt.Printf("map6 类型：%T 值：%v map6 是否为 nil %v \n", map6, map6, map6 == nil) // map6 是 nil，不能使用，因为仅做了声明，没有初始化
fmt.Printf("map7 类型：%T 值：%v map7 是否为 nil %v \n", map7, map7, map7 == nil) // map7 是一个空的map，可以正常使用
/*** Map获取长度函数 len()，结果为键值对个数*/
map8 := map[string]string{"one": "java","two": "python","three": "go",
}fmt.Println(len(map1))/*** 以上运行结果* map1 类型：map[string]int 值：map[a:1 b:2 c:3] map1 是否为 nil false* map2 类型：map[string]int 值：map[a:4 b:5 c:6] map2 是否为 nil false* map3 类型：map[string]int 值：map[a:7 b:8 c:9] map3 是否为 nil false* map4 类型：map[string]int 值：map[a:10 b:11 c:12] map4 是否为 nil false* map5 类型：map[string]int 值：map[a:13 b:14 c:15] map5 是否为 nil false* map6 类型：map[string]int 值：<nil> map6 是否为 nil true* map7 类型：map[string]int 值：map[] map7 是否为 nil false* 3*/
1.2. Map 遍历
/*** Map的遍历*/
map1 := map[string]string{"one": "java","two": "python","three": "go",
}
// 1. fori遍历方式
fmt.Println("1. fori遍历方式")
keys := make([]string, 0, len(map1))
for k := range map1 {keys = append(keys, k)
}
for i := 0; i < len(keys); i++ {fmt.Printf("key=%v value=%v\n", keys[i], map1[keys[i]])
}
// 2. forrange遍历方式
fmt.Println("2. forrange遍历方式")
for k, v := range map1 {fmt.Printf("key=%v value=%v\n", k, v)
}
/*** 结果：* 1. fori遍历方式* key=one value=java* key=two value=python* key=three value=go* 2. forrange遍历方式* key=one value=java* key=two value=python* key=three value=go*/
1.3 Map增删改查
map1 := map[string]string{"one": "java","two": "python","three": "go",
}// map的增删改查
// 增
map1["four"] = "php"
fmt.Printf("map1: %v\n", map1)
// 删
delete(map1, "one")
fmt.Printf("map1: %v\n", map1)
// 改
map1["two"] = "c++"
// 查
value, ok := map1["two"] // ok为true表示存在,为false表示不存在
if ok {fmt.Println(value)
}
value1, ok1 := map1["five"] // ok为true表示存在,为false表示不存在
if ok1 {fmt.Println(value1)
} else {fmt.Println("five不存在")
}
/** 结果* map1: map[four:php three:go two:python]* map1: map[three:go two:python]* c++* five不存在*/
2. function (函数)
函数是一段可重复使用的代码块，用来完成特定的功能
函数的特点有下：
- 函数的作用：提高代码的复用性，提高代码的可读性，提高代码的维护性
- .】函数的返回值：函数的返回值是通过return语句来实现的，return语句可以返回一个值，也可以返回多个值
- 函数的参数：函数的参数是通过函数的参数列表来实现的，参数列表中的参数可以是任意类型，参数列表中的参数可以是任意个数
- 函数变量作用域：函数变量作用域是指在函数内部定义的变量，该变量只能在函数内部使用，函数外部无法访问该变量
- 函数的返回值和参数列表：函数的返回值和参数列表是函数的组成部分，函数的返回值和参数列表是函数的输出和输入，函数的返回值和参数列表是函数的接口，函数的返回值和参数列表是函数的契约
2.1 函数各种定义方式
package mainimport "fmt"/** 函数初识什么是函数：函数是一段可重复使用的代码块，用来完成特定的功能函数的作用：提高代码的复用性，提高代码的可读性，提高代码的维护性函数的定义：func 函数名(参数列表) 返回值列表 {函数体}函数的调用：函数名(参数列表)函数的返回值：函数的返回值是通过return语句来实现的，return语句可以返回一个值，也可以返回多个值函数的参数：函数的参数是通过函数的参数列表来实现的，参数列表中的参数可以是任意类型，参数列表中的参数可以是任意个数函数的返回值和参数列表：函数的返回值和参数列表是函数的组成部分，函数的返回值和参数列表是函数的输出和输入，函数的返回值和参数列表是函数的接口，函数的返回值和参数列表是函数的契约*
*/
// 函数定义
// func 函数名(参数列表) 返回值列表 {
// 函数体
// }
/** 1. 无参数无返回值*/
func sayHello() {fmt.Println("hello world")
}/** 2. 有参数无返回值* @param name string*/
func sayHello2(name string) {fmt.Println("hello", name)
}/*** 2. 有参数有返回值* @param a int* @param b int* @return int*/
func add(a int, b int) int {return a + b
}/** 3. 省略参数类型，此时a的类型与b的类型保持一致* @param a int* @param b int* @return int*/
func add2(a, b int) int {return a + b
}/*** 4. 省略返回值，此时函数的返回值类型为int* @param a int* @param b int* @return int*/
func add3(a, b int) (c int) { // c := a + bc = a + breturn // return c
}/*** 5. 多个返回值* @param a int* @param b int* @return int 之和* @return int 之差*/
func add4(a, b int) (int, int) {return a + b, a - b
}/*** 6. 命名返回值* @param a int* @param b int* @return int 之和* @return int 之差*/
func add5(a, b int) (sum, diff int) {sum = a + bdiff = a - breturn
}/*** 7. 可变参数* @param a ...int* @return int*/
func add6(a ...int) int {sum := 0for _, v := range a {sum += v}return sum
}/*** 8. 函数做形参* @param a int* @param b int* @param op func(int, int) int 表示参数为一个函数，该函数接收两个int类型的参数，返回一个int类型的值*/
func opreate(a, b int, op func(int, int) int) int {return op(a, b) // 调用函数
}/*** 9. 函数做返回值* @param a int* @param b int* @return func() string*/
func add7(a, b int) func() string {// 内部定义一个函数f := func() string {return fmt.Sprintf("%d + %d = %d", a, b, a+b) // 返回一个字符串} // 这里只是定义函数，没有调用函数，调用函数需要使用f()return f // 返回函数
}/*** 10. 匿名函数* 解释：匿名函数是没有名字的函数，匿名函数可以赋值给变量，也可以直接调用** @param a int 数值1* @param b int 数值2* @return func() string 返回类型为一个函数，该函数返回类型为string*/
func add8(a, b int) func() string {return func() string { // 匿名函数的定义，没有函数名return fmt.Sprintf("%d + %d = %d", a, b, a+b) // 返回一个字符串} // 匿名函数的调用
}// main函数 入口函数
func main() {sayHello()sayHello2("张三")fmt.Printf("add %d\n", add(1, 2))fmt.Printf("add2 %d\n", add2(3, 4))fmt.Printf("add3 %d\n", add3(5, 6))sum1, diff1 := add4(7, 8)fmt.Printf("add4 %d %d\n", sum1, diff1)sum2, diff2 := add5(9, 10)fmt.Printf("add5 %d %d\n", sum2, diff2)fmt.Printf("add6 %d\n", add6(1, 2, 3, 4, 5, 6, 7, 8, 9, 10))fmt.Printf("opreate %d\n", opreate(1, 2, add))fmt.Printf("opreate %d\n", opreate(2, 4, func(i1, i2 int) int { // 自定义匿名函数做参数return i1 * i2 // 返回两个数的乘积}))fmt.Printf("add7 %s\n", add7(1, 2)())fmt.Printf("add8 %s\n", add8(3, 4)())/*** 以上运行结果：* hello world* hello 张三* add 3* add2 7* add3 11* add4 15 -3* add5 19 -1* add6 55* opreate 3* opreate 8* add7 1 + 2 = 3* add8 3 + 4 = 7*/
}上一篇：Golang学习历程【第五篇 复合数据类型：数组&切片】
下一篇：Golang学习历程【第七篇 闭包&type defer panic recover了解&time包】 待续中。。。
