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
