GO语言学习之路13

2022/02/04

package main

import (
	"fmt"
	"sort"
)

/*
	map是key-value数据结构，又称为字段或者关联数组，类似其他编程语言的集合

	基本语法： var map变量名 map[keytype]valuetype

	key可以是什么类型
	golang中的map的key可以是很多种类型，比如bool，数字，string， 指针，channel
	还可以是只包含前面几个类型的接口， 结构体， 数组

	****key通常用int， string
	注意： slice， map， function不可以做key；这几个没办法用 == 判断

	****value通常用数字， string， map， struct

	//声明一个map是不会分配内存的，初始化需要make，分配内存后才能赋值和使用

	map使用细节
	1.map是引用类型，遵守引用类型传递的机制，在一个函数接收map，修改后会直接修改原来的map
	2.map容量达到后，再想map增加元素，会自动扩容，不会发生panic，也就说map能动态的增长键值对
	3.map的value也经常使用struct，更适合管理复杂的数据
*/

func main() {
	/*
		map的声明和注意事项

		1.在使用map前需要先make，make的作用就是给map分配数据空间
		2.key 重复会覆盖之前的 value值
		3.golang中的map是无序的
	*/
	var a map[string]string = make(map[string]string, 10)
	a["no1"] = "hello"
	a["no1"] = "world"
	fmt.Println(a)
	/*
		使用map的三种使用方式
		1.先声明，再make
		2.声明和make一起
		3.在声明的时候直接赋值
	*/

	//1.
	var a1 map[string]string = make(map[string]string, 10)
	a1["no1"] = "hello"
	a1["no1"] = "world"
	fmt.Println(a1)

	//2.
	cities := make(map[string]string)
	cities["no1"] = "北京"
	cities["no2"] = "南京"
	cities["no3"] = "郑州"
	fmt.Println(cities)

	//3.
	heros := map[string]string{
		"no1": "g",
		"no2": "g",
		"no3": "g",
	}
	fmt.Println(heros)

	/*
		要存放三个学生的信息， 每个学生有name和sex信息
		使用 map[string]map[string]string
	*/
	studentMap := make(map[string]map[string]string)
	studentMap["stu01"] = make(map[string]string, 2)
	studentMap["stu01"]["name"] = "lll"
	studentMap["stu01"]["sex"] = "man"

	studentMap["stu02"] = make(map[string]string, 2)
	studentMap["stu02"]["name"] = "yyy"
	studentMap["stu02"]["sex"] = "man"

	studentMap["stu03"] = make(map[string]string, 2)
	studentMap["stu03"]["name"] = "fff"
	studentMap["stu03"]["sex"] = "man"

	fmt.Println(studentMap)
	fmt.Println(studentMap["stu02"])
	fmt.Println(studentMap["stu02"]["name"])

	/*
		map的增删改查操作

		1.map的增加和更新(修改)
		map["key"] = value
		如果key还没有，就是增加，如果key存在就是修改

		2.map的删除使用了go的内置函数
		delete(map, "key")
		delete是一个内置函数，
		如果key存在就删除该key-value，如果key不存在，就不操作但是也不会报错

		3.如果我们需要删除map的所有的key，可以遍历key，逐个删除

		4.map查找，如果想看map中是否存在key"no1"
			val, findRes := studentMap["no1"]
			if findRes {
				fmt.Println("找到了val = ", val)
			} else {
				fmt.Println("没有no1这个key")
			}
	*/

	//2.删除
	delete(studentMap, "stu01")
	fmt.Println(studentMap)
	delete(studentMap, "000")
	fmt.Println(studentMap)
	//3.删除所有的key
	//3.1 遍历所有的key，然后逐一删除
	//不能用for循环，拿不到map的下标(key不一定是数字)， 只能用for-range
	for key, value := range studentMap {
		fmt.Printf("key = %v, value = %v\n", key, value)
		for k, v := range value {
			fmt.Printf("k = %v, v = %v\n", k, v)
		}
	}
	for key := range studentMap {
		delete(studentMap, key)
	}
	fmt.Println("delete所有key以后的map,studentMap = ", studentMap)

	//3.2 直接make一个新的空间
	studentMap = make(map[string]map[string]string)
	fmt.Println(studentMap)

	//4.map的查找
	val, findRes := studentMap["stu02"]
	if findRes {
		fmt.Println("找到了val = ", val)
	} else {
		fmt.Println("没有no1这个key")
	}

	//5.map的长度  //统计有多少对 key - value
	fmt.Println("len = ", len(studentMap))

	//6.map的排序
	/*
		1.golang中没有一个专门对map的key进行排序
		2.golang中的map默认是无序的，也不是按照添加的顺序存放的
		3.将map的key放入到切片中，对切片进行排序，遍历切片，按照key输出map的值
	*/
	map1 := map[int]int{
		10: 100,
		1:  13,
		4:  56,
		8:  90,
	}
	fmt.Println("map1 = ", map1)

	var keys []int
	for k := range map1 {
		keys = append(keys, k)
	}
	//排序
	sort.Ints(keys)
	fmt.Println("keys = ", keys)
	//遍历切片按照key顺序来输出
	for _, v := range keys {
		fmt.Printf("map1[%v] = %v\n", v, map1[v])
	}
}

package main

import "fmt"

/*
	map切片
	切片的数据类型如果是map，则我们成为slice of map， map切片
	这样使用则map个数就可以动态变化了
*/
func main() {
	//案例演示
	/*
		使用一个map来记录monster的信息name和age，
		也就是说一个monster对应一个map，并且妖怪的个数可以动态的增加
	*/

	//1.声明一个map切片
	monsters := make([]map[string]string, 2) //准备放两个妖怪的信息
	//2.增加第一个妖怪的信息
	if monsters[0] == nil {
		monsters[0] = make(map[string]string, 2)
		monsters[0]["name"] = "牛魔王"
		monsters[0]["age"] = "500"
	}
	if monsters[1] == nil {
		monsters[1] = make(map[string]string, 2)
		monsters[1]["name"] = "玉兔"
		monsters[1]["age"] = "400"
	}
	// if monsters[2] == nil {  //数组越界
	// 	monsters[2] = make(map[string]string, 2)
	// 	monsters[2]["name"] = "狐狸"
	// 	monsters[2]["age"] = "300"
	// }

	//需要使用切片的append函数，可以动态增加
	//1.先定义一个monster信息
	newMonsters := map[string]string{
		"name": "新妖怪",
		"age":  "500",
	}

	monsters = append(monsters, newMonsters)
	fmt.Println(monsters)
}

package main

import "fmt"

/*
	1. golang不是纯粹的面向对象语言，但是golang支持面向对象编程特性[OOP]
	2. golang没有类，go的结构体和其他变成语言的类(class)有同等的地位，
		可以理解为golang是基于struct来实现OOP特性的
	3. golang面向对象变成非常简洁，
	   去掉了传统的OOP语言的集成，方法重载，构造函数和析构函数，隐藏了this指针等
	4. golang仍然有面向对象编程的集成，封装和多态的特性，只是实现的方式不同
	5.
*/
type Cat struct {
	Name  string
	Age   int
	Color string
	hobby string
}

type Person struct {
	Name string
	Age  int
}

func main() {
	/*
		struct实例
	*/
	var cat1 Cat // var a int
	cat1.Name = "levi"
	cat1.Age = 3
	cat1.Color = "white"
	cat1.hobby = "fish"
	fmt.Println(cat1)

	/*
		创建结构体变量和访问结构体字段的几种方式
		1.直接声明  var cat1 Cat
	*/
	//2.
	p2 := Person{}
	p2.Name = "levi"
	p2.Age = 18
	fmt.Println(p2)
	//3.
	p3 := Person{"mary", 20}
	fmt.Println(p3)
	//4.
	p4 := new(Person)
	(*p4).Age = 18
	p4.Age = 12
	//两种写法等价，标准的字段赋值方式是(*p4).Age = 18
	//go设计者为了方便，底层会对p4.Age = 12 进行处理
	//会给p4加上取值运算符
	var p5 *Person = new(Person)
	fmt.Println(*p4)
	fmt.Println(*p5)

	//5.
	var p6 *Person = &Person{}
	p6.Age = 10
	fmt.Println(*p6)

}

package main

import "fmt"

/*
	1.使用map[string]map[string]string的map类型
	2.key表示用户名，唯一
	3.如果某个用户名存在，就将其密码修改为"888888"， 如果不存在就增加这个用户的信息
	4.编写一个函数完成功能
*/

func modifyUser(users map[string]map[string]string, name string) {
	if users[name] != nil {
		users[name]["pswd"] = "888888"
	} else {
		newUser := make(map[string]string)
		newUser["nickname"] = name + "qwq"
		newUser["pswd"] = "1123"
		users[name] = newUser
	}
}
func main() {
	var users map[string]map[string]string = make(map[string]map[string]string, 10)
	users["smith"] = make(map[string]string, 2)
	users["smith"]["nickname"] = "gaga"
	users["smith"]["pswd"] = "112322"
	modifyUser(users, "smith")
	modifyUser(users, "levi")
	modifyUser(users, "qqq")
	modifyUser(users, "www")

	fmt.Println(users)
}