```

feat(README): 添加课程目录结构

- 添加基础语法与环境搭建链接
- 添加复合数据结构链接
- 添加函数与结构体链接

feat(day02): 完善复合数据结构课程内容

- 添加Go语言数组课程链接
- 添加Go语言切片课程链接
- 添加Go语言Map课程链接

feat(day03): 新增函数与结构体课程模块

- 创建函数与结构体主目录
- 添加函数课程内容
- 添加课程大纲包括函数、defer与异常、结构体、指针等主题

feat(day03/function): 添加Go语言函数基础示例代码

- 实现基本函数定义和调用示例
- 添加不定长参数函数实现
- 添加切片作为参数传递的示例
- 添加引用类型参数传递和指针操作示例
- 包含append操作对底层数组影响的演示代码
```

README.md

@@ -9,3 +9,4 @@
 
 + [基础语法与环境搭建](./day01/README.md)
 + [复合数据结构](./day02/README.md)
++ [函数与结构体](./day03/README.md)

day02/README.md

@@ -13,4 +13,3 @@
 + [Go语言数组](./array/README.md)
 + [Go语言切片](./slice/README.md)
 + [Go语言Map](./map/README.md)
-+ [Go语言结构体](./struct/README.md)

day03/README.md

@@ -0,0 +1,11 @@
+# 函数与结构体
+
+基础数据类型，复合数据类型(数组、切片、Map), 前面章节已经 开始使用函数, 函数的具体使用方法
+
+## 课程内容
+
++ [Go语言函数](./function/README.md)
++ defer与异常
++ Go语言结构体
++ Go语言指针
++ 扩展反射与内存对齐

day03/function/README.md

@@ -0,0 +1,2 @@
+# 函数
+

day03/function/main.go

@@ -0,0 +1,109 @@
+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("任务结束")
+}