go20/day03/function/main.go

110 lines
2.8 KiB
Go
Raw Normal View History

package main
import (
"fmt"
)
func main() {
// 2, 3 实参: 实际传递的参数
// x = 2, y = 3
fmt.Println(sum(2, 3))
// 切片作为参数传递(通过切片来包装多个参数)和多个参数
fmt.Println(sum2([]int{2, 3, 4}))
fmt.Println(sum3(2, 3, 4))
// _ = sum3(2, 3, 4)
// 引用类型示例 底层扩容的影响
// -> 底层数组A未扩容
arg1 := []int{2, 3, 4}
result1 := appendAndChange(arg1)
fmt.Println(result1)
arg2 := []int{2, 3, 4}
appendAndChangeV2(&arg2)
fmt.Println(arg2)
}
// (x int, y int)
// (x,y int)
// var x int
// var y int
// x, y: 形参: 形式参数 (函数定义时的参数,声明的参数)
func sum(x int, y int) int {
return x + y
}
// 切片作为参数传递, 把多个值传递给函数
// 用的时候需要构造切片 []int{2, 3, 4}
func sum2(nums []int) (total int) {
// var total int
for _, num := range nums {
total += num
}
return total
}
// 能不能让函数之间接收多个不确定的参数
// ...int: 不定长参数 --> []int
func sum3(args ...int) (total int) {
// var total int
for _, arg := range args {
total += arg
}
return total
}
// x-> 底层数组指针lencap
// y = x
// y-> 底层数组指针lencap
func appendAndChange(s []int) []int {
fmt.Println(s, len(s), cap(s))
s[0] = 9 // 影响外部底层数组(底层数组未扩容时(A))
s = append(s, 10, 11) // 可能扩容,之后的修改不再影响外部 3 -> 6
fmt.Println(s, len(s), cap(s))
s[0] = 8 // 这一行只影响内部副本(若已扩容(B))
return s
}
// []int -> x
// *[]int -> box(x)
func appendAndChangeV2(s *[]int) {
// 指针的值 copy 到了 v
// []int
// v := *s
// 产生一个新的值复杂对象(赋值的是元数据)
// box(x) -> x
// 这里的v 就不再是s (v值), v 是 s值的一个快照
// 不是操作这个地址本身,操作的是 值
fmt.Println(s, len(*s), cap(*s))
(*s)[0] = 9 // 影响外部底层数组(底层数组未扩容时(A))
// 解开box, 把 10 11 放进去
// s 的扩容就就是box 扩容了,对我们外部可见
*s = append(*s, 10, 11) // 可能扩容,之后的修改不再影响外部 3 -> 6
fmt.Println(s, len(*s), cap(*s))
// 解开box, 看的是扩容后的数组, 真的新的数组进行值的修改对当前box生效
(*s)[0] = 8 // 这一行只影响内部副本(若已扩容(B))
}
type Task struct {
Name string
Params map[string]string
}
// 出来过程中 有报错怎么 返回给调用方
// 执行过程中的日志 怎么返回给调用方
// 同步调用,必须等待任务执行完毕,才能拿到结果
// 通过回调的方式快速 返回给调用方
// 回调函数: 函数作为参数传递
// TaskHandler func(*Task) []string
func TaskHandler(t *Task, logfn func(string)) {
// return []string{"log1", "log2"}
logfn("任务开始")
logfn("任务进行中...")
logfn("任务结束")
}