文章目录

一、结构体
- 1. 结构体创建、访问与修改
- 2. 结构体指针
- 3. 结构体嵌套
- 4. 深拷贝与浅拷贝
二、流程控制语句
- 1. if
- 2. switch
- 3. for
- 4. break与continue
- 5. goto与Label

一、结构体

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 = Student{Id: 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 := []User{{Name: "康熙"}}
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 := []int{1, 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的那一行，把代码再执行一遍（会进入一个无限循环）

if i % 2 == 0 {
	goto L1 // Label指示的是某一行代码，并没有圈定一个代码块，所以goto L1也会执行L2后的代码
} else {
	goto L2 // 先使用Label
}
L1: 
	i += 3
L2: // 后定义Label，Label定义后必须在代码的某个地方被使用
	i *= 3

goto与Label结合可以实现break的功能，甚至比break更强大

for i := 0; i < SIZE; i++ {
L2:
for j := 0; j < SIZE; j++ {
	goto L1
}
L1:
xxx

break、continue与Label结合使用可以跳转到更外层的for循环
continue和break针对的Label必须写在for前面，而goto可以针对任意位置的Label

func break_label() {
	const SIZE = 5
	arr := [SIZE][SIZE]int{}
L1:
	for i := 0; i < SIZE; i++ {
	L2:
		fmt.Printf("开始检查第%d行\n", i)

		if i%2 == 1 {
		L3:
			for j := 0; j < SIZE; j++ {
				fmt.Printf("开始检查第%d列\n", j)
				if arr[i][j]%3 == 0 {
					break L1 // 直接退出最外层的for循环
				} else if arr[i][j]%3 == 1 {
					goto L2 // continue和break针对的Label必须写在for前面，而goto可以针对任意位置的Label
				} else {
					break L3 // 只退出最内层的for循环
				}
			}
		}
	}
}