Go 语言结构体和 map

最新推荐文章于 2023-09-05 00:11:00 发布
最新推荐文章于 2023-09-05 00:11:00 发布
阅读量960 收藏
点赞数
分类专栏： 前端 文章标签： golang
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51927215/article/details/120461906
版权

Go 语言自学

以下原则仅个人娱乐使用：

结构体原则

& 结构体数组固定原则：在数组中容纳的结构体的数目是有限的

& 结构体切片无限大原则：在切片中容纳的结构体的数目是无限的，可以利用 append 函数进行追加

& 结构体数组传递值原则：结构体数组作为函数参数将传递值

& 结构体切片传递地址原则：结构体切片作为函数参数将传递地址

& 结构体首地址指向原则：结构体的首地址指向结构体第一个成员

& 结构体传递值原则：结构体作为函数参数传递时是值传递

map 原则

& map 键值存在原则：利用语句 _, ok := 字典名[字典索引] 返回布尔值来检测

& map 没有也不抱怨原则：若 map 中并没有定义相关键值对，但是却进行了读操作，也不会报错，而是以值对应类型的默认值输出

& map 抛弃元素原则：利用 delete(字典名, key名) 来删除 map 中对应的元素

& map int 对应结构体属性直接写错误：创建 make(map[int]Student) 的 map，通过 m[1].score 直接修改属性是错误的

& map 传递地址原则：map 作为函数参数传递时是地址传递

结构体的声明和初始化

语法：type 结构体名 struct { 结构体成员列表 }

重点：以下程序提及了三种初始化结构体的方法

package main

import "fmt"

// 声明结构体类型 Student
type Student struct {
	id    int
	name  string
	score int
}

func main() {

	// 1. 顺序初始化
	var stu_1 Student = Student{1, "Su shuo han", 100}
	fmt.Println(stu_1) // {1 Su shuo han 100}

	// 2. 自动推导和关键字赋值
	stu_2 := Student{id: 2, name: "Xiao ke", score: 100}
	fmt.Println(stu_2) // {2 Xiao ke 100}

	// 3. 先声明后赋值
	// 声明结构体
	var stu_3 Student
	// 初始化
	stu_3.id = 3
	stu_3.name = "Xiao jia"
	stu_3.score = 100
	fmt.Println(stu_3) // {3 Xiao jia 100}
}

第一种：按照顺序初始化结构体

var stu_1 Student = Student{1, "Su shuo han", 100}

第二种：按照关键词传参初始化结构体（自动推导）

stu_2 := Student{id: 2, name: "Xiao ke", score: 100}

第三种：先声明结构体然后赋值

var stu_3 Student
stu_3.id = 3
stu_3.name = "Xiao jia"
stu_3.score = 100

结构体名的含义 – 首地址

重点：结构体的首地址和结构体内首元素的地址相同（即结构体首地址指向原则）；且取结构体的地址需要用到 & 符号（即结构体名指向第一个成员的地址）

package main

import "fmt"

// 声明结构体类型 Student
type Student struct {
	id    int
	name  string
	score int
}

func main() {

	// 初始化结构体
	stu_1 := Student{1, "Su", 100}

	// 打印结构体的首地址和结构体首个元素的地址
	fmt.Printf("%p\n", &stu_1)    // 0xc0000443c0
	fmt.Printf("%p\n", &stu_1.id) // 0xc0000443c0
}

结构体联系数组和切片

以下程序用一个长度为 3 的数组来容纳 3 个结构体

package main

import "fmt"

// 声明结构体类型 Student
type Student struct {
	id    int
	name  string
	score int
}

func main() {

	// 初始化结构体数组
	var arr_Student [3]Student = [3]Student{
		{1, "Xiao su", 100},
		{2, "Xiao ke", 100},
		{3, "Liu jia", 100},
	}

	// 分别打印结构体数组中的元素
	for i := 0; i < len(arr_Student); i++ {
		fmt.Println("序号：", arr_Student[i].id, "名字：", arr_Student[i].name, "分数：", arr_Student[i].score)
	}

	// outputs:序号： 1 名字： Xiao su 分数： 100
	// 		   序号： 2 名字： Xiao ke 分数： 100
	//         序号： 3 名字： Liu jia 分数： 100
}

利用数组容纳结构体（即数组结构体固定原则），需要定义数组的长度，也就是说容纳结构体的数量有限

var arr_Student [3]Student // 3 个

以下程序用一个切片来容纳结构体

package main

import "fmt"

// 声明结构体类型 Student
type Student struct {
	id    int
	name  string
	score int
}

func main() {

	// 初始化结构体切片
	var arr_Student []Student = []Student{
		{1, "Xiao su", 100},
		{2, "Xiao ke", 100},
		{3, "Liu jia", 100},
	}

	// 打印结构体切片
	fmt.Println(arr_Student) // [{1 Xiao su 100} {2 Xiao ke 100} {3 Liu jia 100}]

	// 利用 append 函数追加数据(追加的是 Student 类型的结构体)
	arr_Student = append(arr_Student, Student{4, "Xiao li", 100}, Student{5, "Xiao ze", 100})

	// 打印结构体切片
	fmt.Println(arr_Student) // [{1 Xiao su 100} {2 Xiao ke 100} {3 Liu jia 100} {4 Xiao li 100} {5 Xiao ze 100}]
}

利用切片容纳结构体（即切片结构体无限大原则），不需要提前声明结构体的数目（可以用 append 函数追加）

var arr_Student []Student

结构体作为函数参数

重点：值传递（即结构体传递值原则）

package main

import "fmt"

type Student struct {
	id    int
	score int
}

func display(stu Student) {
	stu.score = 200

	fmt.Println(stu) // {1 200}
}

func main() {
	stu_1 := Student{1, 100}

	// 调用函数
	display(stu_1)

	fmt.Println(stu_1) // {1 100}
}

结构体数组和切片作为函数参数

结构体数组作为函数参数相当于传递值（即结构体数组传递值原则）

package main

import "fmt"

// 声明结构体类型 Student
type Student struct {
	id    int
	name  string
	score int
}

// 冒泡排序
func bubbleSort(arr [3]Student) {
	for i := 0; i < len(arr)-1; i++ {
		for j := 0; j < len(arr)-1-i; j++ {
			if arr[j].score > arr[j+1].score {
				arr[j], arr[j+1] = arr[j+1], arr[j]
			}
		}
	}

	fmt.Println(arr) // [{2 Xiao ke 78} {3 Liu jia 92} {1 Xiao su 100}]
}

func main() {

	// 初始化结构体切片
	var arr_Student [3]Student = [3]Student{
		{1, "Xiao su", 100},
		{2, "Xiao ke", 78},
		{3, "Liu jia", 92},
	}

	// 调用排序函数 -- 根据 score 从小到大排序
	bubbleSort(arr_Student) // 切片作为函数参数 -- 地址传递

	// 在 main 函数中输入排序后的结果
	fmt.Println(arr_Student) // [{1 Xiao su 100} {2 Xiao ke 78} {3 Liu jia 92}]
}

结构体切片作为函数参数相当于传递地址（即结构体切片传递值原则）

package main

import "fmt"

// 声明结构体类型 Student
type Student struct {
	id    int
	name  string
	score int
}

// 冒泡排序
func bubbleSort(arr []Student) {
	for i := 0; i < len(arr)-1; i++ {
		for j := 0; j < len(arr)-1-i; j++ {
			if arr[j].score > arr[j+1].score {
				arr[j], arr[j+1] = arr[j+1], arr[j]
			}
		}
	}
}

func main() {

	// 初始化结构体切片
	var arr_Student []Student = []Student{
		{1, "Xiao su", 100},
		{2, "Xiao ke", 78},
		{3, "Liu jia", 92},
	}

	// 调用排序函数 -- 根据 score 从小到大排序
	bubbleSort(arr_Student) // 切片作为函数参数 -- 地址传递

	// 在 main 函数中输入排序后的结果
	fmt.Println(arr_Student) // [{2 Xiao ke 78} {3 Liu jia 92} {1 Xiao su 100}]
}

map 的声明和初始化

事先声明：map 相当于其它语言里的字典

语法：var 字典名 map[键类型]值类型

如下程序可以比较一下数组、切片及 map 声明的不同之处

package main

import "fmt"

func main() {

	// 空数组
	var arr_int [3]int
	fmt.Println(arr_int) // [0 0 0]

	// 空切片
	var slice_int []int
	fmt.Println(slice_int) // []

	// 空 map
	var m map[int]string
	fmt.Println(m) // map[]
}

重点：空 map 和空切片不可以进行赋值和取值操作

package main

func main() {

	var slice_int []int
	// slice_int[0] = 0 // Error!

	var m map[int]sting
	// m[0] = "Xiao su" // Error!
}

第一处重点：map 属性 – 长度

package main

import "fmt"

func main() {

	// 空 map
	var m map[int]string

	// 长度
	fmt.Println(len(m)) // 0
}

第二处重点：map 的初始化

语法：字典名 := make(map[键类型]值类型)

重点：map 的数据无序；map 的长度自动扩容

package main

import "fmt"

func main() {

	// 声明非空的 map 变量
	m := make(map[int]string)

	// 赋值
	m[0] = "Xiao su"

	fmt.Println(m) // map[0:Xiao su]
}

map 的键和值

自定义场景一：学生对应其三门课程成绩

package main

import "fmt"

func main() {

	// 定义键为 string 类型 值为 [3]int 的数组的 map
	m := make(map[string][3]int)

	// 分别赋值
	m["Xiao su"] = [3]int{100, 90, 100}
	m["Xiao ke"] = [3]int{100, 100, 90}
	m["Xiao lo"] = [3]int{90, 100, 100}

	fmt.Println(m) // map[Xiao ke:[100 100 90] Xiao lo:[90 100 100] Xiao su:[100 90 100]]
}

自定义场景二：序号对应学生

package main

import "fmt"

func main() {

	// 定义键为 string 类型 值为 [3]int 的数组的 map
	m := make(map[int]string)

	// 分别赋值
	m[1] = "Xiao ke"
	m[2] = "Xiao su"
	m[3] = "Xiao lo"

	fmt.Println(m) // map[1:Xiao ke 2:Xiao su 3:Xiao lo]
}

自定义场景三：序号对应学生的个人信息

package main

import "fmt"

type Student struct {
	id    int
	name  string
	score int
}

func main() {

	// 定义键为 string 类型 值为 [3]int 的数组的 map
	m := make(map[int]Student)

	// 分别赋值
	m[1] = Student{1, "Xiao su", 100}
	m[2] = Student{2, "Xiao ku", 100}
	m[3] = Student{3, "Xiao ki", 100}

	fmt.Println(m) // map[1:{1 Xiao su 100} 2:{2 Xiao ku 100} 3:{3 Xiao ki 100}]

	// 需要注意的如下操作是不被予许的（即 map int 对应结构体属性直接写错误原则）
	// m[1].score = 1000 // Error!

	stu := m[1]
	stu.score = 1000
	m[1] = stu

	fmt.Println(m) // map[1:{1 Xiao su 1000} 2:{2 Xiao ku 100} 3:{3 Xiao ki 100}]
}

自定义场景四：序号对应班级内部的学生信息

package main

import "fmt"

type Student struct {
	id    int
	score int
}

func main() {

	m := make(map[int][]Student)

	// 代表 1 班 中的二个学生
	// 一个学生 100 分 -- 另一个学生 90 分
	m[1] = []Student{
		{1, 100},
		{2, 90},
	}

	// 现在我们增加第三个学生
	m[1] = append(m[1], Student{3, 80})

	fmt.Println(m) // map[1:[{1 100} {2 90} {3 80}]]
}

重点1：判断键值对是否存在（即 map 键值存在原则）

重点2：不存在某键值对将打印对应类型默认值（即 map 没有也不抱怨原则）

重点3：删除 map 中的元素（即 map 删除元素原则）

package main

import "fmt"

func main() {

	m := make(map[int]string)

	m[0] = "Xiao su"

	fmt.Println(m) // map[0:Xiao su]

	// 1. 查询键值对是否存在
	_, ok := m[4]
	fmt.Println(ok) // false
	_, ok = m[0]
	fmt.Println(ok) // true

	// 2. 打印不存在的键值对
	fmt.Println(m[5]) // 空字符

	// 3. 删除键值对 -- 根据 key 值
	delete(m, 0)

	fmt.Println(m) // map[]
}

map 作为函数参数

重点：地址传递（即 map 传递地址原则）

package main

import "fmt"

func Change(m map[int]string) {
	m[1] = "Xiao ke"
}

func main() {

	m := make(map[int]string)

	m[1] = "Xiao su"

	fmt.Println(m) // map[1:Xiao su]

	Change(m)

	fmt.Println(m) // map[1:Xiao ke]
}
是我来晚了！
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
go语言映射与结构体
云水
08-30 1841
映射与结构体 映射 结构体 映射与结构体 映射 func main() { var mmp = map[string]int{} var mmp1 map[string]int var mmp2 = map[string]int{&amp;amp;quot;id号&amp;amp;quot;: 001, &amp;amp;quot;学号&
go语言基础（三）：map、结构体
alin的博客
10-26 2052
go语言基础（三）：map、结构体 1. map 语法：var map的名字 map[键类型]值类型 = make(map[键类型]值类型) map的名字 := make(map[键类型]值类型) 如果不写后面的make的话会报错 map在定义后不需要给它指定大小就能进行使用，和切片这一点不同要区分 对于map直接使用map名[键值]=数据值，就可以进行数据的添加 func main() { var m map[int]string = make(map[int]string) m[0] =
Go 学习笔记（65）— Go 中函数参数是传值（函数参数为数组、切片、map、chan、struct 等）
wohu1104的专栏
11-19 3108
package main import "fmt" func main() { // 示例1。 array1 := [3]string{"a", "b", "c"} fmt.Printf("The array: %v\n", array1) array2 := modifyArray(array1) fmt.Printf("The modified array: %v\n", array2) fmt.Printf("The original array: %v\n", array1) f.
golang语言-map作为函数参数传递
西京刀客
09-13 7960
golang语言-map作为函数参数传递 func main(){ m := make(map[int]int) m[1] = 1 fmt.Printf("原始map的内存地址是：%p\n", m) modify(m) fmt.Println("map值被修改了，新值为:", m) } func modify(m interface{}){ fmt.Printf("函数里接收到map的内存地址是：%p\n", m) p := m.(map[int]int) p[1] = 2 } 如上： 在
Go map作为函数参数 (引用传递，修改形参会影响到实参)
m0_67393039的博客
08-16 783
代码】Go map作为函数参数 (引用传递，修改形参会影响到实参)
golang sync.Map 在函数传参时默认是值传递
Lucky小黄人的博客
09-05 692
概要 今天改了一段代码，调用函数时把一个 sync.Map 类型的变量作为传参，在函数内部修改 sync.Map 变量的值，发现函数处理完成后，外部的变量没有修改，后来发现 sync.Map 是一个普通的结构体，跟所有的结构体一样，golang 在把结构体类型作为函数传参时，都是值传递，即创建参数的一个副本，然后传递给函数。这也就意味着，如果你在函数内部修改了这个副本的值，那么原始的值是不会被影...
go语言结构体转换map、map转换结构体、json字符串转结构体、结构体数据转换到别的结构体
01-07
1.结构体转map 2.map转结构体 3.结构体数据转移到结构体 4.json字符串转结构体 package main import ( encoding/json fmt reflect ) type User struct { Name string `json:name` Age int `json:age` } func ...
Go-mapstructure-Go库用于解码泛型map值成Go结构体
03-09
在Go编程语言中，处理来自各种来源的数据，如JSON、XML或自定义协议时，将这些数据转换为Go结构体是常见的需求。`go-mapstructure`库提供了解决这一问题的有效工具，它允许我们将泛型的`map[string]interface{}`类型...
Go-structomap-容易和动态生成地从Go静态结构体生成Map
08-13
总的来说，`structomap`是一个强大的工具，它使得Go语言中的结构体与Map之间的转换变得更加便捷和灵活。通过理解和运用这个库，开发者可以更专注于业务逻辑，而不是基础的数据转换工作。在实际项目中，合理利用`...
Go语言基础、进阶、提高课程第六节 Go语言结构体，切片，map，游戏用户留存1
08-03
第六节 Go 语言结构体、切片、map,游戏用户留存 21、结构体 22、切片 53、map（映射）结构 74、课后作业—难度： 135、如何提升用户留存 13
Go 语言课程和项目源码
最新发布
06-21
Go语言Map Go语言接口 错误处理 空接口与类型断言 函数式编程 面向对象 面向接口 作业 Day06 IO操作 反射与AST 文件读写 包与工程 单元测试和基准测试 Go语言进阶 Day09 密码学简介 散列算法 对称加密算法 非对称...
Go语言中Map类型的传递
小俊侠的博客
04-28 3338
【Map 类型】先看例子:func main() { m1 := make(map[int]int) mdMap1(m1) fmt.Println(m1) //实参的内容改变了 =&gt; map[2:200 1:100] var m2 map[int]int //只是声明，并未分配内存 chgMap2(m2) fmt.Println(m2) //实参的内容并未改变 =&gt...
Go语言中的值传递和引用传递 附: 内存地址分析
即使再小的帆也能远航，加油~
11-29 1390
对于值传递来说，在传递过程中，传递的是数据的副本，在其它函数中修改数据，并不会对原始数据产生影响。那么对于引用传递来说，变量在内存中的存放在一定的地址上，修改变量实际上就是修改变量所在地址处的内容。
go里基本数据、结构体、map、数组中值传递与地址传递分析
weixin_34381687的博客
12-11 529
2019独角兽企业重金招聘Python工程师标准>>> ...
go语言学习之数组、map
lzh
07-01 5219
任何语言都提供了数组这一特殊的存储结构，各有各的好处。go语言的数组和常规编程语言的数组差不多，只不过它还提供了一个称之为切片的容器（你可以把它理解为可变长的数组），切片的定义方法为：slice []int，仔细看跟数组定义的方式一样，只不过是它没有确定的大小，go语言中称这种变量为切片。切片我们需要了解三个东西：prt是一个指针，存储当前对切片操作的最后一次位置或者当前位置，len是切片的长度，...
深入Go的Map使用和实现原理
Ch3nnn的博客
11-03 320
最后我们分析一下go的整体内存结构，阅读一下map存储的源码，如下图所示，当往map中存储一个kv对时，通过k获取hash值，hash值的低八位和bucket数组长度取余，定位到在数组中的那个下标，hash值的高八位存储在bucket中的tophash中，用来快速判断key是否存在，key和value的具体值则通过指针运算存储，当一个bucket满时，通过overfolw指针链接到下一个bucket。接下来我们一探究竟。看了上面的map创建，初始化，增删改查等操作，我们发现go的api其实挺简单易学的。
Go基础 数组 切片 Map
m0_46937429的博客
10-13 1774
数组可以存放多个同一类型数据 数组也是一种数据类型 在Go 中数组是指类型1)切片的英文是slice2)切片是数组的一个引用，因此切片是引用类型，在进行传递时，遵守引用传递的l机制。3)切片的使用和数组类似，遍历切片、访问切片的元素和求切片长度len(slice)都一样。4)切片的长度是可以变化的，因此切片是一个可以动态变化数组。5)切片定义的基本语法:var变量名[类型比如: var a [] int。
【golang】实现数组 map 方法
小辣抓
05-02 9293
【golang】实现数组 map 方法 经常会在项目里用到数组的 map 方法，闲来无事打算在 golang 中实现一下 map 方法。上工具要先上用法 numbers := []int{1, 2, 3} // convert to []interface{} interfaceNumbers, err := utils.ToInterface(numbers) utils.Check(err...
go语言（5）数组和切片
weixin_43823255的博客
11-30 782
数组 1.数组定义：var 数组名 [数组大小] 数组类型 var a [5]int 2.(1)数组的地址可以通过数组名来获取：&a (2)数组第一个元素的地址就是数组的首地址 3.数组初始化的四种方式
go语言结构体
05-30
Go语言的结构体可以看作是一种自定义的数据类型，它由一组字段组成。结构体中的字段可以是任意类型，包括基本类型、数组、切片、map、函数、甚至是其他结构体。 定义一个结构体的语法为： ```go type StructName struct { Field1 Type1 Field2 Type2 ... } ``` 其中，StructName是结构体的名称，Field1、Field2等是结构体的字段名，Type1、Type2等是对应字段的数据类型。 我们可以通过结构体字面量来创建一个结构体对象： ```go s := StructName{Field1: value1, Field2: value2, ...} ``` 其中，value1、value2等是对应字段的值。 我们也可以通过指针来访问结构体的字段： ```go s := &StructName{Field1: value1, Field2: value2, ...} s.Field1 = newValue1 s.Field2 = newValue2 ``` 这里s是一个指向结构体的指针，可以通过"."来访问结构体的字段。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

是我来晚了！

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值