Go基础结构体和流程控制语句
Posted Ricky_0528
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Go基础结构体和流程控制语句相关的知识，希望对你有一定的参考价值。
文章目录
一、结构体
1. 结构体创建、访问与修改
定义结构体
type User struct
id int
score float32
enrollment time.Time
name, addr string // 多个字段类型相同时可以简写到一行里
声明和初始化结构体
var u User // 声明，会用相应类型的默认值初始化struct里的每一个字段
u = User // 用相应类型的默认值初始化struct里的每一个字段
u = User id: 3, name: "ricky" // 指定字段进行赋值初始化
u = User 4, 100.0, time.Now(), "ricky", "cn" // 赋值初始化，可以不写字段名，但必须跟结构体定义里的字段顺序一致
访问与修改结构体
u.enrollment = time.Now() // 给结构体的成员变量赋值
fmt.Printf("id=%d, enrollment=%v, name=%s\\n", u.id, u.enrollment, u.name) // 访问结构体的成员变量
成员方法
// 可以把User理解为hello函数的参数，即hello(u user, man string)
func (u User) hello(man string)
fmt.Println("hi " + man + ", my name is " + u.name)
// 函数里不需要访问User的成员，可以传匿名，甚至_也不传，直接写成User
func (_ User) think(man string)
fmt.Println("hi " + man + ", do you know my name?")
为自定义类型添加方法
type UserMap map[int]User // 自定义类型
// 可以给自定义类型添加任意方法
func (um UserMap) GetUser(id int) User
return um[id]
结构体的可见性：
- go语言关于可见的统一规则是大写字母开头跨package也可以访问，否则只能本package内部访问
- 结构体名称以大写开头时，package外部可见，在此前提下，结构体中以大写开头在成员变量或成员方法在package外部也可见
匿名结构体
var stu struct // 声明stu是一个结构体，但这个结构体是匿名的
Name string
Addr string
stu.Name = "ricky"
stu.Addr = "cn"
匿名结构体通常用于只使用一次的情况。
结构体中含有匿名成员
type Student struct
Id int
string // 匿名字段
float32 // 直接使用数据类型作为字段名，所以匿名字段中不能出现重复的数据类型
var stu = StudentId: 1, string: "ricky", float32: 79.5
fmt.Printf("anonymous_member string member=%s float member=%f\\n", stu.string, stu.float32) // 直接使用数据类型访问匿名成员
2. 结构体指针
创建结构体指针
var u User
user := &u // 通过取址符&得到指针
user = &User // 直接创建结构体指针
Id: 3, Name: "ricky", addr: "cn",
user = new(User) // 通过new()函数实体化一个结构体，并返回其指针
构造函数
// 构造函数，返回指针是为了避免值拷贝
func NewUser(id int, name string) *User
return &User
Id: id,
Name: name,
addr: "China",
Score: 59,
方法接收指针
// user传的是值，即传的是整个结构体的拷贝，在函数里修改结构体不会影响原来的结构体
func hello(u User, man string)
u.name = "杰克"
fmt.Println("hi " + man + ", my name is " + u.name)
// 传的是User指针，在函数里修改User的成员会影响原来的结构体
func hello2(u *User, man string)
u.name = "杰克"
fmt.Println("hi " + man + ", my name is " + u.name)
// 把User理解为hello()的参数，即hello(u User, man string)
func (u User) hello(man string)
u.name = "杰克"
fmt.Println("hi " + man + ", my name is " + u.name)
// 可以理解为hello2(u *User, man string)
func (u *User) hello2(man string)
u.name = "杰克"
fmt.Println("hi " + man + ", my name is " + u.name)
3. 结构体嵌套
type User struct
name string
sex byte
type Paper struct
name string
auther User // 结构体嵌套
p := new(Paper)
p.name = "论文标题"
p.auther.name = "作者姓名"
p.auther.sex = 0
type Vedio struct
length int
name string
User // 匿名字段，可用数据类型当字段名
结构体嵌套时字段名冲突的问题
v := new(vedio)
v.length = 13
v.name = "视频名称"
v.User.sex = 0 // 通过字段名逐级访问
v.sex = 0 // 对于匿名字段也可以跳过中间字段名，直接访问内部的字段名
v.User.name = "作者姓名" // 由于内部、外部结构体都有name这个字段，名字冲突了，所以需要指定中间字段名
4. 深拷贝与浅拷贝
type User struct
Name string
type Vedio struct
Length int
Author User
Go语言里的赋值都会发生值拷贝
type User struct
Name string
type Vedio struct
Length int
Author *User
- 深拷贝，拷贝的是值，比如Vedio.Length。
- 浅拷贝，拷贝的是指针，比如Vedio.Author。
- 深拷贝开辟了新的内存空间，修改操作不影响原先的内存。
- 浅拷贝指向的还是原来的内存空间，修改操作直接作用在原内存空间上
传slice，对sclice的3个字段进行了拷贝，拷贝的是底层数组的指针，所以修改底层数组的元素会反应到原数组上
users := []UserName: "康熙"
func update_users(users []User)
users[0].Name = "光绪"
二、流程控制语句
1. if
if 5 > 9
fmt.Println("5 > 9")
- 如果逻辑表达式成立，就会执行里的内容
- 逻辑表达式不需要加()
- ""必须紧跟在逻辑表达式后面，不能另起一行
// 初始化多个局部变量，复杂的逻辑表达式
if c, d, e := 5, 9, 2; c < d && (c > e || c > 3)
fmt.Println("fit")
- 逻辑表达中可以含有变量或常量
- if句子中允许包含1个（仅1个）分号，在分号前初始化一些局部变量（即只在if块内可见）
if-else的用法
color := "black"
if color == "red" // if只能有一个
fmt.Println("stop")
else if color == "green"
fmt.Println("go")
else if color == "yellow" // else if可以有0个、一个或者连续多个
fmt.Println("stop")
else // else有0个或1个
fmt.Printf("invalid traffic signal: %s\\n", strings.ToUpper(color))
if表达式嵌套
if xxx
if xxx
else if xxx
else
else
if xxx
else
注意不要使用太深的if嵌套，会增加代码的维护代价，比如
if (true)
if (true)
if (true)
if (true)
if (true)
2. switch
color := "black"
switch color
case "green" : // 相当于 if color== "green"
fmt.Println("go")
case "red" : // 相当于 else if color== "red"
fmt.Println("stop")
default: // 相当于 else
fmt.Printf("invalid traffic signal: %s\\n", strings.ToUpper(color))
- switch-case-default可能模拟if-else if-else，但只能实现相等判断
- switch和case后面可以跟常量、变量或函数表达式，只要它们表示的数据类型相同就行
- case后面可以跟多个值，只要有一个值满足就行
func add(a int) int
return a + 10
func switch_expression()
var a int = 5
switch add(a) // switch后跟一个函数表达式
case 15: // case后跟一个常量
fmt.Println("right")
default:
fmt.Println("wrong")
const B = 15
switch B // switch后跟一个常量
case add(a): // case后跟一个函数表达式
fmt.Println("right")
default:
fmt.Println("wrong")
switch后带表达式时，switch-case只能模拟相等的情况；如果switch后不带表达式，case后就可以跟任意的条件表达式
func switch_condition()
color := "yellow"
switch color
case "green":
fmt.Println("go")
case "red", "yellow": // 用逗号分隔多个condition，它们之间是“或”的关系，只需要有一个condition满足就行
fmt.Println("stop")
// switch后带表达式时，switch-case只能模拟相等的情况；如果switch后不带表达式，case后就可以跟任意的条件表达式
switch
case add(5) > 10:
fmt.Println("right")
default:
fmt.Println("wrong")
switch Type
func switch_type()
var num interface = 6.5
// 获取interface的具体类型。.(type)只能用在switch后面
switch num.(type)
case int:
fmt.Println("int")
case float32:
fmt.Println("float32")
case float64:
fmt.Println("float64")
case byte:
fmt.Println("byte")
default:
fmt.Println("neither")
// 相当于在每个case内部申明了一个变量value
switch value := num.(type)
case int: // value已被转换为int类型
fmt.Printf("number is int %d\\n", value)
case float64: // value已被转换为float64类型
fmt.Printf("number is float64 %f\\n", value)
case byte, string: // 如果case后有多个类型，则value还是interface类型！
fmt.Printf("number is inerface %v\\n", value)
default:
fmt.Println("neither")
// 等价形式
switch num.(type)
case int:
value := num.(int)
fmt.Printf("number is int %d\\n", value)
case float64:
value := num.(float64)
fmt.Printf("number is float64 %f\\n", value)
case byte:
value := num.(byte)
fmt.Printf("number is byte %d\\n", value)
default:
fmt.Println("neither")
fallthrough，当命中某一个case时，强行进入下一个case，默认情况下命中之后就跳出switch
func fall_throth(age int)
fmt.Printf("您的年龄是%d, 您可以：\\n", age)
switch
case age > 50:
fmt.Println("出任国家首脑")
fallthrough
case age > 25:
fmt.Println("生育子女")
fallthrough
case age > 22:
fmt.Println("结婚")
fallthrough
case age > 38:
fmt.Println("开车")
fallthrough
case age > 16:
fmt.Println("参加工作")
case age > 15:
fmt.Println("上高中")
fallthrough
case age > 3:
fmt.Println("上幼儿园")
3. for
arr := []int1, 2, 3, 4, 5
// 正序遍历切片
for i := 0; i < len(arr); i++
fmt.Printf("%d: %d\\n", i, arr[i])
for 初始化局部变量; 条件表达式; 后续操作
for sum, i := 0, 0; i < len(arr) && sum < 100; sum, i = sum*1, i+1
- 局部变量指仅在for块内可见
- 初始化变量可以放在for上面
- 后续操作可以放在for块内部
- 只有条件判断时，前后的分号可以不要
- for是一个无限循环，相当于while true
for range
- 遍历数组或切片：
for i, ele := range arr - 遍历string：
for i, ele := range "我会唱ABC" // ele是rune类型 - 遍历map，go不保证遍历的顺序：
for key, value := range m - 遍历channel，遍历前一定要先close：
for ele := range ch // for range拿到的是数据的拷贝
for嵌套
矩阵乘法需要用到三层for循环嵌套。
func nest_for()
const SIZE = 4
A := [SIZE][SIZE]float64
// 初始化二维数组
// 两层for循环嵌套
for i := 0; i < SIZE; i++
for j := 0; j < SIZE; j++
A[i][j] = rand.Float64() // [0,1)上的随机数
B := [SIZE][SIZE]float64
for i := 0; i < SIZE; i++
for j := 0; j < SIZE; j++
B[i][j] = rand.Float64() // [0,1)上的随机数
rect := [SIZE][SIZE]float64
// 三层for循环嵌套
for i := 0; i < SIZE; i++
for j := 0; j < SIZE; j++
prod := 0.0
for k := 0; k < SIZE; k++
prod += A[i][k] * B[k][j]
rect[i][j] = prod
i, j := 2, 1
fmt.Println(A[i]) // 二维数组第i行
// 打印二维数组的第j列
// 注意：B[:][j]这不是二维数组第j列，这是二维数组第j行！
for _, row := range B
fmt.Printf("%g ", row[j])
fmt.Println()
fmt.Println(rect[i][j])
4. break与continue
- break与continue用于控制for循环的代码流程，并且只针对最靠近自己的外层for循环
- break:退出for循环，且本轮break下面的代码不再执行
- continue:本轮continue下面的代码不再执行，进入for循环的下一轮
// break和continue都是针对for循环的，不针对if或switch
// break和continue都是针对套在自己外面的最靠里的那层for循环，不针对更外层的for循环（除非使用Label）
func complex_break_continue()
const SIZE = 5
arr := [SIZE][SIZE]int
for i := 0; i < SIZE; i++
fmt.Printf("开始检查第%d行\\n", i)
if i % 2 == 1
for j := 0; j < SIZE; j++
fmt.Printf("开始检查第%d列\\n", j)
if arr[i][j] % 2 == 0
continue // 针对第二层for循环
fmt.Printf("将要检查第%d列\\n", j+1)
break // 针对第一层for循环
5. goto与Label
var i int = 4
MY_LABEL:
i += 3
fmt.Println(i)
goto MY_LABEL // 返回定义MY_LABEL的那以上是关于Go基础结构体和流程控制语句的主要内容，如果未能解决你的问题，请参考以下文章