Go语言字典
- 概念
- 字典和数组切片一样也是用来保存一组相同类型数据的
- 数组和切片能通过相应的索引/下标获得对应的值
- 字典能通过对应的key来获得对应的值,key 由自己定义
- 个人理解 GO语言中的字典就相当于是完全自定义的数组或切片
- 定义格式
var 字典名称 map [ key的数据类型 ] value的数据类型
var dict map[int]int
-
注意点:
字典也需要初始化之后才能使用
- 如何创建字典
1. 通过GO语言的自带语法创建
package main
import "fmt"
func main() {
// 第一种格式
var dict map[int]int = map[int]int{0:7,1:9,2:11}
//第二种
var dict1 map[int]int
dict1 = map[int]int{0:1,1:666,2:888}
fmt.Println("dict = ",dict) // dict = map[0:7 1:9 2:11]
fmt.Println("dict1 = ",dict1) // dict1 = map[0:1 1:666 2:888]
}
2. 通过make() 函数创建字典
-
格式
make ( 字典数据类型, 字典长度 ) -----> 长度可以不写 -
如果知道要定义的字典长度最好写上
package main
import "fmt"
func main() {
var dict map[int]int // 定义一个字典变量
dict = make(map[int]int,3)
dict[0] = 7
dict[1] = 9
dict[2] = 11
fmt.Println("dict = ",dict) // dict = map[0:7 1:9 2:11]
}
- 如果定义了字典,没有初始化的话 其长度是
0
package main
import "fmt"
func main() {
var dict map[int]int
dict = make(map[int]int)
var dict1 map[int]int
dict1 = make(map[int]int,3)
fmt.Println(len(dict)) // 0
fmt.Println(len(dict1)) // 0
}
- 遍历字典
package main
import "fmt"
func main() {
dict := map[string]string{"name":"小明","age":"18"}
for key,value := range dict{
fmt.Println("key = ",key,"value = ",value)
}
}
字典的曾删改查
1.增加
- 如果字典中没有对应的key就是增加
- 注意点 字典中不能有重名的
[key] - 格式
字典名称[key] = 值
dict[3] = 666
2.修改
字典名称[key] = 值 ----> 有对应的值就是修改
package main
func main() {
dict := map[string]string{"name":"小明","age":"18"}
dict["name"] = "小红"
}
3.查询
- 格式
value , ok := 字典名称 [ 查询的key值 ] ----------> value , ok := dict [ " name " ]
package main
import "fmt"
func main() {
dict := map[string]string{"name":"小明","age":"18"}
dict["name"] = "小红"
value,ok := dict["name"]
fmt.Println(ok) // true
fmt.Println(value) // 小红
}
- 企业中标准的查询字典的写法
package main
import "fmt"
func main() {
dict := map[string]string{"name":"小明","age":"18"}
if value,ok := dict["name"];ok{
fmt.Println(ok)
fmt.Println(value)
}
}
4.删除
- 格式
delete( 字典名称 , key值)
package main
import "fmt"
func main() {
dict := map[string]string{"name":"小明","age":"18"}
delete(dict,"name")
fmt.Println(dict) // map[age:18]
}
字典的注意点
- 字典和切片一样是地址传递,所以字典作为函数参数时修改形参会影响实参
- 字典里保存的数据是
无序的
Go语言结构体
概念
- 和C语言一样,go语言中的结构体也是用来保存不同数据类型
- 需要先定义结构体类型,在定义结构体变量
-
结构体定义完就可以使用
定义格式
type 结构体名称 struct{
属性1名称 数据类型
属性2名称 数据类型
属性3名称 数据类型
}
- 实例
package main
func main() {
//定义结构类型
type person struct{
name string
age int
height int
}
}
定义结构体变量
- 格式
var 结构体变量名称 结构体类型
- 实例
package main
func main() {
//定义结构类型
type person struct{
name string
age int
height int
}
var people person // people 是结构体变量
}
结构体变量初始化
- 定义的同时初始化
-
注意点如果部分初始化需要指定属性名称
package main
func main() {
//定义结构类型
type person struct{
name string
age int
height int
}
// 定义的同时初始化
var people person = person{"小红",18,170} //完全初始化
}
- 先定义再初始
package main
func main() {
//定义结构类型
type person struct{
name string
age int
height int
}
// 定义结构变量
var people person
people.name = "小红"
people.age = 18
people.height = 170
}
结构体注意点
- 结构体和函数一样 作为参数传入函数里,外界实参不会被改变
- 如果结构体中包含切片和字典类型 需要先初始化在使用
- 结构体之间的转换 必须保证结构体的属性名称 属性数据类型 属性个数完全一样才能转换
匿名结构体属性
- 匿名结构体属性就是有数据类型没有属性名称
type Person struct {
int // 只有数据类型, 没有名称, 就是匿名属性
name string
}
- 结构体嵌套是如何操作属性
结构体变量 . 属性名称
type Person struct {
age int
name string
}
var p person // 定义结构题变量
p. age
p.name
- 嵌套
结构体变量 . 嵌套的结构体类型 . 嵌套结构里的属性
- 嵌套的注意点
- 结构体属性类型不能是当前结构体类型
- 嵌套时只有结构体里的匿名属性才会向上去寻找
- 如果嵌套的结构体中有重名的属性时,系统会就近原则,现在自己的结构体里寻找,如果没有再去嵌套的结构里寻找
package main
import (
"fmt"
)
func main() {
type Object struct{
name string
}
type Person struct{
name string
}
type Student struct {
Object
Person
name string
score int
}
stu := Student{Object{"Object"},Person{"person"},"student",99}
fmt.Println(stu.name) // student
fmt.Println(stu.Object.name) // Object
fmt.Println(stu.Person.name) // person
}
网友评论