Golang学习历程【第六篇 复合数据类型map&函数初识】

Golang学习历程【第六篇 复合数据类型map&函数初识】

• [1. Map数据类型](#1. Map数据类型)
• • [1.1. Map声明和初始化](#1.1. Map声明和初始化)
  • [1.2. Map 遍历](#1.2. Map 遍历)
  • [1.3 Map增删改查](#1.3 Map增删改查)
• [2. function (函数)](#2. function (函数))
• • [2.1 函数各种定义方式](#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 (函数)

函数是一段可重复使用的代码块，用来完成特定的功能

函数的特点有下：

1. 函数的作用：提高代码的复用性，提高代码的可读性，提高代码的维护性
2. .】函数的返回值：函数的返回值是通过return语句来实现的，return语句可以返回一个值，也可以返回多个值
3. 函数的参数：函数的参数是通过函数的参数列表来实现的，参数列表中的参数可以是任意类型，参数列表中的参数可以是任意个数
4. 函数变量作用域：函数变量作用域是指在函数内部定义的变量，该变量只能在函数内部使用，函数外部无法访问该变量
5. 函数的返回值和参数列表：函数的返回值和参数列表是函数的组成部分，函数的返回值和参数列表是函数的输出和输入，函数的返回值和参数列表是函数的接口，函数的返回值和参数列表是函数的契约

2.1 函数各种定义方式

package main

import "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 + b
	c = a + b
	return // 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 + b
	diff = a - b
	return
}

/**
 * 7. 可变参数
 * @param a ...int
 * @return int
 */
func add6(a ...int) int {
	sum := 0
	for _, 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&闭包】 待续中。。。