0. 序言

从这章开始，在Go基础语法里难度就开始上来了
在学习函数与方法前，先弄明白指针是很重要的。

1. 指针

在没学指针前，相信很多人就已经大概知道指针是个什么东西了。因为它太有名了，当然是与 C和C++ 的出名有关。

1.1 指针的含义

Go保留的指针，在一定程度上保证了性能，同时为了更好的GC和安全考虑，又限制了指针的使用

1. 指针属于基本数据类型，遍历存的就是值，也叫做值类型

2. 获取遍历的地址，使用 &

   比如：var num int，想要获取num遍历的地址，使用 &num

3. 获取指针类型所指向的值，使用：*

   比如：var *t int,使用 *p 获取 p 指向的值

   指针类型，指针变量存的是一个地址，这个地址指向的空间的才是值

   var p *int = &num

   这行代码的意思就是说，p变量指针,指向了num变量的地址的值

   1. p是一个指针变量
   2. p指针变量的类型是 *int 类型
   3. p本身的值 &i

var i int = 10
var p *int = &i // 指向的变量类型需与指针类型一致
fmt.Println(&i) // &i代表的就是i变量的内存地址：0xc00000a0e8
fmt.Println(p)  // 这里p变量的值就是&i：0xc00000a0e8

！指针必须指向某个变量的地址！

指针变量同样也是有地址的

// 输出 p 指针变量的内存地址
fmt.Println(&p) // 0xc000110048

• 这是在内存中，指针指向的空间关系

指针变量会在内存中开辟一块空间（地址：0xc000110048），然后在这个空间中存放的是某变量的内存地址（0xc00010c098）通常这种写法就是：&变量名。

而想要获取指针变量的值，其实也就是指向的变量内容

// 获取 p 指针变量的值
fmt.Println(*p) // 10

它获取值的流程：

1. 先获取到p指针变量的内存地址 0xc000110048
2. 去这个0xc000110048内存地址中找存放的值0xc00010c098
3. 然后由于它是指针变量，所以还需要根据这个值0xc00010c098 再来内存中查找对应的内存地址
4. 根据值0xc00010c098找到对应的内容10。

1.2 用法

关于指针有两个常用的操作符，一个是取地址符&，另一个是解引用符*。对一个变量进行取地址，会返回对应类型的指针，例如：

func main() {
   num := 2
   p := &num
   fmt.Println(p) // 指针存储的是变量num的地址 0xc00001c088
}

解引用符则有两个用途，第一个是访问指针所指向的元素，也就是解引用，例如

func main() {
	num := 2
	p := &num
	rawNum := *p
	fmt.Println(rawNum)
}

p是一个指针，对指针类型解引用还有一个用途就是声明一个指针

func main() {
   var numPtr *int
   fmt.Println(numPtr) // <nil>
}

*int即代表该变量的类型是一个int类型的指针，不过指针不能光声明，还得初始化，需要为其分配内存，否则就是一个空指针，无法正常使用。

要么使用取地址符将其他变量的地址赋值给该指针，要么就使用内置函数new手动分配，例如：

func main() {
   // var numPtr *int
   // numPtr = new(int)
   numPtr := new(int) // 更推荐写法
   fmt.Println(numPtr)
}

new函数只有一个参数那就是类型，并返回一个对应类型的指针，函数会为该指针分配内存，并且指针指向对应类型的零值，例如：

func main() {
   fmt.Println(*new(string)) // 
   fmt.Println(*new(int))// 0
   fmt.Println(*new([5]int))// [0 0 0 0 0]
   fmt.Println(*new([]float64))// []
}

1.3 禁止指针运算

在Go中是不支持指针运算的，也就是说指针无法偏移

func main() {
   arr := [5]int{0, 1, 2, 3, 4}
   p := &arr
   println(&arr[0])
   println(p)
   // 试图进行指针运算
   p++ // main.go:10:2: invalid operation: p++ (non-numeric type *[5]int)
   fmt.Println(p)
}

虽然正常时不支持指针运算的，但是你可以引入标准库unsafe来完成运算

标准库unsafe提供了许多用于低级编程的操作，其中就包括指针运算。

1.4 new 和 make

在前面已经很多次提到过内置函数new和make，两者有点类似，但也有不同，下面复习下

func new(Type) *Type

• 返回值是类型指针
• 接受参数是类型
• 专用于给指针分配内存空间

func make(t Type, size ...IntegerType) Type

• 返回值是值，不是指针
• 接受的第一个参数是类型，不定长参数根据传入类型的不同而不同
• 专用于给切片，映射表，通道分配内存

例子：

new(int) // int指针
new(string) // string指针
new([]int) // 整型切片指针
make([]int, 10, 100) // 长度为10，容量100的整型切片 
make(map[string]int, 10) // 容量为10的映射表
make(chan int, 10) // 缓冲区大小为10的通道

1.5 属于指针的使用陷阱

var a int = 300
var b int = 400
var p *int = &a
*p = 100
p = &b
*p = 200
fmt.Printf("a = %d, b = %d, *p = %d\n", a, b, *p) // a = 100, b = 200, *p = 200

这里*p的其实指向的就是变量a的内容，所以，给*p重新赋值，就意味着给a变量重新赋值

值类型，都有对应的指针类型，形式为 *数据类型，比如int的对应的指针就是*intf,loat32对应的指针类型就是 *float，以此类推

值类型包括：基本数据类型int系列、float系列、bool、string、数组和结构体struct

2. 结构体

2.1 介绍

结构体可以存储一组不同类型的数据，是一种符合类型。

Go抛弃了类与继承，同时也抛弃了构造方法，刻意弱化了面向对象的功能，Go并非是一个传统OOP的语言，但是Go依旧有着OOP的影子，通过结构体和方法也可以模拟出一个类。下面是一个简单的结构体的例子

OOP：面向对象编程

2.2 声明

type Result struct {
	code int
	msg  string
	data any
}

结构体本身以及内部字段都遵守大小写命名的暴露方式。

同时，相邻字段也可以不用重复声明数据类型

type Infomation struct {
	name, address     string
	age, schoolNumber string
}

在声明结构体字段时，字段名不能与方法名重复

2.3 实例化

Go不存在构造方法，大多数情况下采用如下的方式来实例化结构体，初始化的时候就像map一样指定字段名称再初始化字段值

result := Result{
    code: 1,
    msg:  "好人",
    data: true,
}
fmt.Println(result)

不过也可以省略字段名称，当省略字段名称时，就必须初始化所有字段。

通常不建议使用这种方式，因为可读性很糟糕

2.4 指针

对于结构体指针而言，不需要解引用就可以直接访问结构体的内容，例子如下：

p := &Person{
   name: "jack",
   age:  18,
}
fmt.Println(p.age,p.name)

在编译的时候会转换为(*p).name ，(*p).age，其实还是需要解引用，不过在编码的时候可以省去，算是一种语法糖。

2.5 标签

结构体标签是一种元编程的形式，结合反射可以做出很多奇妙的功能

`key1:"val1" key2:"val2"`

type Programmer struct {
    Name     string `json:"name"`
    Age      int `yaml:"age"`
    Job      string `toml:"job"`
    Language []string `properties:"language"`
}

2.6 空结构体

空结构体没有字段，不占用内存空间，我们可以通过unsafe.SizeOf函数来计算占用的字节大小

func main() {
   type Empty struct {}
   fmt.Println(unsafe.Sizeof(Empty{}))// 0
}

空结构体的使用场景有很多，比如之前提到过的，作为map的值类型，可以将map作为set来进行使用，又或者是作为通道的类型，表示仅做通知类型的通道

3. 函数

3.1 声明

func 函数名([参数列表]) [返回值]{
	函数体
}

函数签名由函数名称，参数列表，返回值组成

声明函数的有两种办法，一种是通过func关键字直接声明，另一种就是通过var关键字来声明

函数名称为Sum，有两个int类型的参数a，b，返回值类型为int。

func sum1(a int, b int) int {
	return a + b
}

var sum = func(a int, b int) int {
	return a + b
}

在Go中，方法是没有重载这一说的

Go的理念：如果签名不一样那就是两个完全不同的函数，那么就不应该取一样的名字，函数重载会让代码变得混淆和难以理解。

type Person struct {
	Name    string
	Age     int
	Address string
	Salary  float64
}

func NewPerson(name string, age int, address string, salary float64) *Person {
	return &Person{Name: name, Age: age, Address: address, Salary: salary}
}
// 不可以重载
func NewPerson(name string) *Person {
	return &Person{Name: name}
}

3.2 参数

Go中的参数名可以不带名称，一般这种是在接口或函数类型声明时才会用到，不过为了可读性一般还是建议尽量给参数加上名称

type ExWriter func(io.Writer) error 

type Writer interface {
	ExWrite([]byte) (int, error)
}

对于类型相同的参数而言，可以只需要声明一次类型，不过条件是它们必须相邻

同时：变长参数可以接收0个或多个值，但必须声明在参数的末尾

func main() {
	a := test(2, 4, 6)
	fmt.Println(a)
    b, c := test1(3, 5, 1, 1, 5, 77, 111)
	fmt.Println(b, c) // 239 测试
}

func test(n1, n2, n3 int) int {
	return n1 + n2
}

/*
当存在边长参数，那么该参数会是一个切片
*/
func test1(n1 int, n3 ...int) (int, string) {
	a := 0
	for i := range n3 {
		n1++
		a += n3[i] + n1
	}
	return a, "测试"
}

Go中的函数参数是传值传递，即在传递参数时会拷贝实参的值。

因为这两个数据结构本质上都是指针，所以不用担心在传递时赋值大量内存

3.3 返回值

• 一个简单的函数返回值的例子，Sum函数返回一个int类型的值。

• 而当函数没有返回值时，不需要void，不带返回值即可。

• Go允许函数有多个返回值，此时就需要用括号将返回值围起来

func main() {
	sum_1(1, 2)
	test2()
}

/*
相加函数，返回一个int类型
*/
func sum_1(a, b int) int {
	return a + b
}
/*
测试函数，不返回任何的值
*/
func test2() {
	fmt.Println("....")
}

/*
测试函数，返回两个变量
*/
func test1(n1 int, n3 ...int) (int, string) {
	a := 0
	for i := range n3 {
		n1++
		a += n3[i] + n1
	}
	return a, "测试"
}

Go也支持具名返回值，不能与参数名重复，使用具名返回值时，return关键字可以不需要指定返回哪些值。

/*
确认某个变量作为返回值
*/
func test3() (num int) {
	num = 10
	return
}

/*
确认多个变量作为返回值
*/
func test4() (num, age int) {
	num = 10
	age = 50
	return
}

其实，返回的那段代码(num, age int)就已经声明了返回的变量，所以无需指定使用return返回固定的参数了

但是不管具名返回值如何声明，永远都是以return关键字后的值为最高优先级

3.4 匿名函数

匿名函数就是没有签名的函数，例如下面的函数func(a, b int) int，它没有名称，所以我们只能在它的函数体后紧跟括号来进行调用。

a := func(a, b int) int {
    return a + b
}(1, 2)
fmt.Println(a)// 3

这种的话，还可以配合方法套方法，反正也是返回一个参数，那么哪里需要参数，哪里就能用这种方法

如果只函数只是使用一次，可以考虑使用匿名函数，不过匿名函数也可以实现多次调用

复杂例子：

package main

import "fmt"

func main() {
	var num1, num2 int

	fmt.Println("------第一个数字参数")
	fmt.Scanln(&num1)
	fmt.Println("------第二个数字参数")
	fmt.Scanln(&num2)

	var data = test5(num1, num2, func() (b string) {
		fmt.Println("------请输入填写字符")
		fmt.Scanln(&b)
		fmt.Println("------得到值：", b)
		return
	}())
	fmt.Println("最终生成对象结果：", data)

}

type Result struct {
	Code    int
	Message string
	Data    any
}
func test5(a, b int, s string) Result {
	result := Result{}

	num := a + b
	if num >= 0 {
		result.Code = 200
		result.Message = s + " 进入0大于等于判断"
		result.Data = num
	} else {
		result.Data = num
		result.Code = 500
		result.Message = s + " 相加值"
	}

	return result
}

这里复杂例子，就是使用了匿名函数，直接返回一个作为方法参数的变量

3.5 闭包

闭包（Closure）这一概念，在一些语言中又被称为Lamda表达式，与匿名函数一起使用，闭包 = 函数 + 环境引用

换言之：闭包就是一个函数和与其相关的引用环境组合的一个整体（实体）

这里 addAndPrint() 返回的参数是一个函数( func(string) int )，

func main() {
    // 由于 addAndPrint() 是个方法，所以这里使用变量来接受
	f1 := addAndPrint() // 这里用f1变量来接收返回的函数，所以那个匿名函数的名称就可以说是f1
	num1 := f1("第一次第一次")// 这里调用 f1 变量匿名函数
	fmt.Println(num1)
}

func addAndPrint() func(string) int {
	var n int = 10
    // 返回一个匿名函数
	return func(str string) int {
		n++
		fmt.Println("打印字符串：", str)
		return n
	}
}

3.6 init函数

每个源文件都可以包含一个init函数，该函数会在main函数执行前被Go调用

package main

import "fmt"

func init() {
	fmt.Println("init") // init
}

func main() {
}

1. 如果一个文件同时包含全局变量定义，init函数和main函数，则执行的流程：全局变量定义》init函数》main函数
2. ini函数最主要的作用，就是完成一些初始化的工作
3. init函数执行的流程是怎么样的？或者说，当源文件存在互相的调用时，执行流程是怎样的？
   首先执行调用文件（调用关系中最上级的文件）中的执行流程，然后再执行被调用文件的执行流程

3.7 延迟调用

defer关键字可以使得一个函数延迟一段时间调用，在函数返回之前这些defer描述的函数最后都会被逐个执行

func main() {
	test6()
}
func test6() {
	// defer 关键字 延迟函数的触发时间
	defer func() {
		fmt.Println("1")
	}()
	fmt.Println("2")
}

//2
//1

虽然没有明令禁止，一般建议不要在for循环中使用defer

func main() {
	n := 5
	for i := range n {
		defer fmt.Println(i)
	}
}

这段代码结果是正确的，但过程也许不对。在Go中，每创建一个defer，就需要在当前协程申请一片内存空间。假设在上面例子中不是简单的for n循环，而是一个较为复杂的数据处理流程，当外部请求数突然激增时，那么在短时间内就会创建大量的defer，在循环次数很大或次数不确定时，就可能会导致内存占用突然暴涨，这种我们一般称之为内存泄漏。

对于defer直接作用的函数而言，它的参数是会被预计算的，这也就导致了上述这种奇怪现象，对于这种情况，尤其是在延迟调用中将函数返回值作为参数的情况尤其需要注意。

4. 方法

方法与函数的区别在于，方法是有接收者的。

type M map[int]string

func (arr M) SetThis(i int, v string) {
    arr[i] = v
}
func (arr M) Get(i int) string {
	return arr[i]
}

func main() {
	var a M = make(map[int]string)
	M.SetThis(a, 1, "张三")
	M.SetThis(a, 3, "李四")
	M.SetThis(a, 4, "王五")

	a.SetThis(5, "赵六") // 推荐
	fmt.Println(a)
	fmt.Println(a.Get(3))
}

上部分代码其实可以看成是（Java角度）：

1. 新建了一个M类
2. 为M类创建了一个静态的SetThis()方法
3. 创建的a对象继承自M类
4. 所以a对象可以调用方法，使用M类也可以调用方法

5. 😍前篇知识回顾

1. Go的环境安装与开发工具配置
2. Go的运行流程步骤与包的概念
3. （Go）变量与常量？字面量与变量的较量！
4. 初上手Go？本篇文章帮拿捏Go的数据类型！
5. （Go语言）条件判断与循环？切片和数组的关系？映射表与Map？三组关系傻傻分不清？本文带你了解基本的复杂类型与执行判断语句

6. 💕👉 其他好文推荐

• 还不了解Git分布式版本控制器？本文将带你全面了解并掌握
• 带你认识Maven的依赖、继承和聚合都是什么！有什么用？
• 2-3树思想与红黑树的实现与基本原理
• !全网最全! ElasticSearch8.7 搭配 SpringDataElasticSearch5.1 的使用
• 全面深入Java GC！！带你完全了解 GC垃圾回收机制！！
• 全面了解Java的内存模型（JMM）！详细清晰！
• 在JVM中，类是如何被加载的呢？本篇文章就带你认识类加载的一套流程！

全文资料学习全部参考于：Golang中文学习文档