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-> 底层数组指针，len，cap
// y = x
// y-> 底层数组指针，len，cap
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("任务结束")
}