go语言 map工具库 go语言map定义

map数据类型：key:value数据类型的数据结构，又叫字典或关系组。

map是引用类型。

 

一、map定义与初始化

1.1、map定义

var map01 map[string]string     // 声明key是字符串类型，值是字符串类型的map
var map02 map[string]int        // 声明key是字符串类型，值是整型的map
var map03 map[int]string        // 声明key是整型，值是字符串类型的map
var map04 map[string]map[string]string     // 声明key是字符串类型，值是map类型的map

map定义后需要初始化后才可以使用，如果不初始化直接使用会panic。

 

1.2、map初始化

可以在定义map的时候直接给map赋值，也可以使用make函数来初始化map，下面是map的定义与初始化示例：

func testMap() {

    // 方法一、先定义map，然后make初始化map，最后赋值
    var a map[string]string      // 声明名为a的map (支持简写，:= 的方式)
    a = make(map[string]string,10)     // 初始化a，长度等于10
    a["name"] = "dream"      // 赋值操作
    a["age"] = "18"

    // 方法二、通过推导的方式直接make初始化，然后赋值
    a := make(map[string]string,10)     // 定义与初始化a，长度等于10
    a["name"] = "dream"      // 赋值操作
    a["age"] = "18"

    // 方法三、定义与赋值一起操作了（// map[key的类型]value类型）
    var a map[string]string = map[string]string{
        "name": "dream",
        "age": "18",
    }
    fmt.Println(a)      // 结果为：map[age:18 name:dream]

        // 方法四、key是string，值是map类型的map定义与初始化
        a := make(map[string]map[string]string, 10)      // 定义与初始化一个值为map类型的map
    a["person_obj"] = make(map[string]string)         // 初始化值的map（由于值类型是map，需要先初始化值的map，如果不初始化调用就会报错）
        a["test"] = make(map[string]string)               // 初始化第二个值得map类型
    
    // 往map里插入数据
    a["person_obj"]["name"] = "dream"              // 赋值操作（插入数据）
    a["person_obj"]["age"] = "22"
    a["person_obj"]["salary"] = "20000"
        a["test"]["name"] = "zs"
        a["test"]["age"] = "80"
    fmt.Println(a)        // 查看结果，结果为：map[person_obj:map[age:22 name:dream salary:20000] test:map[age:80 name:zs]]

    // 方法五： 直接定义，后面在使用
    message := map[string]string{}
    message["msg"] = "生成验证码失败，请联系管理员"
    message["Code"] = "500"

}

　　

 二、map的增删该查操作

func testMap2() {
	a := make(map[string]map[string]string, 10)      // 定义与初始化一个值为map的map
	a["person_obj"] = make(map[string]string)         // 初始化值的map（由于值类型是map，需要先初始化值得map，如果不初始化调用就会报错）

	
	// 往map里插入数据
	a["person_obj"]["name"] = "dream"              // 赋值操作（插入数据）
	a["person_obj"]["age"] = "22"
	a["person_obj"]["salary"] = "20000"
	fmt.Println(a)        // 结果为：map[person_obj:map[age:22 name:dream salary:20000]]

	// 从map里获取数据
	k, ok := a["person_obj"]          // 获取数据,k的值为key对应的值，ok为判断值是否存在（有值时ok为true、无值时ok为false）
	if ok {
		fmt.Println(k)     // 结果为：map[age:22 name:dream salary:20000]
		fmt.Println(k["name"])    // 结果为：dream
	}
	fmt.Println(ok)     // 结果为：true

	// 删除map里的数据（如果要清空一个map只能for循环一个一个的删，或者重新make一下）
	delete(a["person_obj"], "salary")
	fmt.Println(a)

	// 遍历map(map的值是map时需要使用两个循环)
	for k, v := range a {
		fmt.Println(k)
		for k1, v1 := range v {
			fmt.Println(k1,v1)
		}
	}

	// 打印map长度
	fmt.Println(len(a))

	// 更新操作
	a["person_obj"]["age"] = "23"
	fmt.Println(a)
}

　　

三、map实战联系

3.1、给未知map进行赋值操作（不知道这个未知的map有没有初始化）

package main

import "fmt"

func testMap3(a map[string]map[string]string) {
	_, ok := a["zhangsan"]
	if !ok {        // 判断a这个map里有没有“zhangsan”这个key，如果没有这个值就初始化值这个map，还可以这么判断（如果张三这个值为空就初始化）：if a["zhangsan"] == nil {执行初始化}
		a["zhangsan"] = make(map[string]string)     // 没有值就初始化值这个map
	}
	a["zhangsan"]["password"] = "123456"      // 给值这个map赋值
	a["zhangsan"]["email"] = "[e-mail]"
	fmt.Println("in make :",a)        // 结果为：in make : map[zhangsan:map[email:[e-mail] password:123456]]
	return       // 遇到return后，代码就不向下执行了
}

func main() {
        a := make(map[string]map[string]string, 100)
	testMap3(a)
}

　　

3.2、切片里的元素是map的操作

package main

import "fmt"
func mapDemo1() {
    var mapSlice = make([]map[string]string, 3)    // 初始化切片，mapSlice[0]为map
    fmt.Println(mapSlice)    // 结果为：[map[] map[] map[]]

    // 对切片中的map元素进行初始化
    mapSlice[0] = make(map[string]string, 10)       // 初始化切片的第一个元素（也就是map）
    mapSlice[0]["name"] = "小王子"        // 给切片的第一个元素（map）赋值
    mapSlice[0]["password"] = "123456"
    mapSlice[0]["address"] = "沙河"
    fmt.Println(mapSlice)          // 结果为：[map[address:沙河 name:小王子 password:123456] map[] map[]]
    for index, value := range mapSlice {
        fmt.Printf("index:%d value:%v\n", index, value)
    }
}
// 循环的执行结果为：
// index:0 value:map[address:沙河 name:小王子 password:123456]
// index:1 value:map[]
// index:2 value:map[]

func main() {
        mapDemo1()
}

　　

3.3、map里的值为切片类型的操作

func mapDemo2() {
	var sliceMap = make(map[string][]string, 3)    // 初始化一个map[字符串类型]切片类型，长度为3
	fmt.Println("sliceMap:",sliceMap)     // 结果：map[]
	key := "中国"
	value, ok := sliceMap[key]      // 判断key存不存在sliceMap这个字典里
	if !ok {    // 如果map里不存在key这个值
		value = make([]string, 2)    // 初始化一个切片并赋值给value
	}
	value = append(value, "北京", "上海")    // 使用append()函数往value切片里追加："北京", "上海" 两个值
	sliceMap[key] = value     // 给sliceMap 赋值，[中国] = "北京", "上海"
	fmt.Println(sliceMap)     // 结果为：map[中国:[北京 上海]]
}

　　

3.4、int类型的map排序

func testMapSort() {
	a := make(map[int]int,5)      // 定义与初始化一个map

	a[1] = 10         // 添加数值
	a[3] = 11
	a[5] = 12
	a[8] = 13

	var keys []int      // 定义一个空切片
	for k, _ := range a {     // 循环map获取map的key
		keys = append(keys, k)       // 往keys切片里写入循环获取到的map的key
	}
	sort.Ints(keys)      // 通过sort包向的Ints排序keys切片里面的key
	for _, v := range keys {
		fmt.Println(v,a[v])      // 根据排序后的key获取map里面的值

	}
}

// 执行结果为：
1 10
3 11
5 12
8 13

　　

3.5、两个map之间的反转

func mapRevert() {
	a := make(map[string]int,5)           // 定义并初始化两个map
	b := make(map[int]string,5)

	a["abc"] = 135        // 给a map赋值
	a["def"] = 246
	fmt.Println("map a:",a)      // 结果为：map a: map[abc:135 def:246]

	for k, v := range a {      // 循环a map
		b[v] = k      // 给b map赋值，b的键等是a的值、值是a的键
	}
	fmt.Println("map b:",b)    // 结果为：map b: map[135:abc 246:def]
}