0. 序言

从这章开始，在Go基础语法里难度就开始上来了

在学习函数与方法前，先弄明白指针是很重要的。

1. 指针

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

1.1 指针的含义

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

指针属于基本数据类型，遍历存的就是值，也叫做值类型
获取遍历的地址，使用 &
比如：var num int，想要获取num遍历的地址，使用 &num
获取指针类型所指向的值，使用：*
比如：var *t int,使用 *p 获取 p 指向的值

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

var p *int = &num

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

p是一个指针变量

p指针变量的类型是 *int 类型

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

它获取值的流程：

先获取到p指针变量的内存地址 0xc000110048
去这个0xc000110048内存地址中找存放的值0xc00010c098
然后由于它是指针变量，所以还需要根据这个值0xc00010c098 再来内存中查找对应的内存地址
根据值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() {
}

如果一个文件同时包含全局变量定义，init函数和main函数，则执行的流程：全局变量定义》init函数》main函数

ini函数最主要的作用，就是完成一些初始化的工作

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角度）：

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

5. 😍前篇知识回顾

6. 💕👉 其他好文推荐

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

【Golang】（4）Go里面的指针如何？函数与方法怎么不一样？带你了解Go不同于其他高级语言的语法