go基础-7.函数和指针

函数是一段封装了特定功能的可重用代码块，用于执行特定的任务或计算

函数接受输入（参数）并产生输出（返回值）

函数定义

package main

import "fmt"

// 使用func关键字定义一个函数
func sayHello() {
  fmt.Println("hello")
}

func main() {
  // 函数()调用函数
  sayHello()
}

函数参数

package main

import "fmt"

func add(n1 int, n2 int) {
  fmt.Println(n1, n2)
}

// 参数类型一样，可以合并在一起
func add1(n1, n2 int) {
  fmt.Println(n1, n2)
}

// 多个参数
func add2(numList ...int) {
  fmt.Println(numList)
}

func main() {
  add(1, 2)
  add1(1, 2)
  add2(1, 2)
  add2(1, 2, 3, 4)
}

函数返回值

package main

import "errors"

// 无返回值
func fun1() {
  return // 也可以不写
}

// 单返回值
func fun2() int {
  return 1
}

// 多返回值
func fun3() (int, error) {
  return 0, errors.New("错误")
}

// 命名返回值
func fun4() (res string) {
  return // 相当于先定义再赋值
  //return "abc"
}

func main() {

}

匿名函数

package main

import "fmt"

func main() {
  var add = func(a, b int) int {
    return a + b
  }
  fmt.Println(add(1, 2))
}

高阶函数

根据用户输入的不同，执行不同的操作

package main

import "fmt"

func main() {
  fmt.Println("请输入要执行的操作：")
  fmt.Println(`1：登录
2：个人中心
3：注销`)
  var num int
  fmt.Scan(&num)
  var funcMap = map[int]func(){
    1: func() {
      fmt.Println("登录")
    },
    2: func() {
      fmt.Println("个人中心")
    },
    3: func() {
      fmt.Println("注销")
    },
  }
  funcMap[num]()
}

提取出来

package main

import "fmt"

func login() {
  fmt.Println("登录")
}

func userCenter() {
  fmt.Println("个人中心")
}

func logout() {
  fmt.Println("注销")
}

func main() {
  fmt.Println("请输入要执行的操作：")
  fmt.Println(`1：登录
2：个人中心
3：注销`)
  var num int
  fmt.Scan(&num)
  var funcMap = map[int]func(){
    1: login,
    2: userCenter,
    3: logout,
  }
  funcMap[num]()
}

闭包

设计一个函数，先传一个参数表示延时，后面再次传参数就是将参数求和

例如

fun(2)(1,2,3) // 延时2秒求1+2+3

package main

import (
  "fmt"
  "time"
)

func awaitAdd(t int) func(...int) int {
  time.Sleep(time.Duration(t) * time.Second)
  return func(numList ...int) int {
    var sum int
    for _, i2 := range numList {
      sum += i2
    }
    return sum
  }
}

func main() {
  fmt.Println(awaitAdd(2)(1, 2, 3))
}

值传递和引用传递

稍微了解过编程的都应该知道，计算机上显示的所有的数据都是在内存里面的

也就是说，我们定义的一个变量，它也在内存里面有一块地

正常情况下来说，函数的参数是将之前那块地复制了一份出来

如何证明呢

package main

import "fmt"

func add(num int) {
  fmt.Println(&num) // 可以看到，这个n的内存地址和外面num的内存地址是明显不一样的
  num = 2           // 这里的修改不会影响外面的num
}

func main() {
  num := 20
  fmt.Println(&num)
  add(num)
  fmt.Println(num) // 20
}

也就是说，在函数里面不管怎么修改这个参数，都不会影响原来的那个值

但是，如果我需要在函数体内修改变量的值呢？

这就需要用到引用传递了

我们直接将变量的内存地址传递进去

package main

import "fmt"

func add(num *int) {
  fmt.Println(num) // 内存值是一样的
  *num = 2         // 这里的修改会影响外面的num
}

func main() {
  num := 20
  fmt.Println(&num)
  add(&num)
  fmt.Println(num) // 成功修改 2
}

指针

上面那个案例搞清楚之后，指针也就不难了

我们只需要知道

&是取地址，*是解引用，去这个地址指向的值

参考文档

函数 https://zhuanlan.zhihu.com/p/635927865

指针 https://c.biancheng.net/view/21.html

go语言函数 https://blog.csdn.net/weixin_44211968/article/details/121295530