完善Go语言学习文档，增加详细代码示例和练习项目

docs/phase1-basics.md

@@ -35,20 +35,78 @@ func main() {
 - 基本类型：int, float, bool, string
 - 复合类型：数组、切片、映射
 - 类型转换与类型推断
+- 指针类型基础
+- 自定义类型与类型别名
+
+#### 基本类型示例
+```go
+package main
+
+import "fmt"
+
+func main() {
+    // 数值类型
+    var i int = 42
+    var f float64 = 3.14
+    var b bool = true
+    var s string = "Go语言"
+    
+    fmt.Printf("int: %d, float64: %f, bool: %t, string: %s\n", i, f, b, s)
+    
+    // 类型转换
+    var x int = 10
+    var y float64 = float64(x)
+    fmt.Printf("x: %d, y: %f\n", x, y)
+}
+```
+
+#### 复合类型示例
+```go
+package main
+
+import "fmt"
+
+func main() {
+    // 数组（固定长度）
+    var arr [5]int = [5]int{1, 2, 3, 4, 5}
+    fmt.Println("数组:", arr)
+    
+    // 切片（动态长度）
+    var slice []int = []int{1, 2, 3}
+    slice = append(slice, 4) // 添加元素
+    fmt.Println("切片:", slice)
+    
+    // 映射（键值对）
+    var m map[string]int = make(map[string]int)
+    m["one"] = 1
+    m["two"] = 2
+    fmt.Println("映射:", m)
+}
+```
 
 ### 1.5 变量与常量
 ```go
-// 变量声明
-var name string = "Go"
-var age = 25
-score := 95.5
+package main
 
-// 常量
-const PI = 3.14159
-const (
-    StatusOK = 200
-    StatusNotFound = 404
-)
+import "fmt"
+
+func main() {
+    // 变量声明
+    var name string = "Go"
+    var age = 25
+    score := 95.5
+    
+    fmt.Printf("name: %s, age: %d, score: %f\n", name, age, score)
+    
+    // 常量
+    const PI = 3.14159
+    const (
+        StatusOK = 200
+        StatusNotFound = 404
+    )
+    
+    fmt.Printf("PI: %f, StatusOK: %d, StatusNotFound: %d\n", PI, StatusOK, StatusNotFound)
+}
 ```
 
 ### 1.6 控制结构
@@ -56,34 +114,751 @@ const (
 - for循环（只有for一种循环）
 - switch多路选择
 - defer延迟执行
+- goto与标签（了解即可）
+
+#### 条件语句示例
+```go
+package main
+
+import "fmt"
+
+func main() {
+    // if/else
+    age := 20
+    if age >= 18 {
+        fmt.Println("成年人")
+    } else {
+        fmt.Println("未成年人")
+    }
+
+    // if with initialization
+    if num := 10; num%2 == 0 {
+        fmt.Println(num, "是偶数")
+    }
+}
+```
+
+#### 循环语句示例
+```go
+package main
+
+import "fmt"
+
+func main() {
+    // 基本for循环
+    for i := 0; i < 5; i++ {
+        fmt.Println(i)
+    }
+
+    // 类似while的for循环
+    sum := 1
+    for sum < 100 {
+        sum += sum
+        fmt.Println("sum:", sum)
+    }
+
+    // 无限循环（带退出条件）
+    count := 0
+    for {
+        count++
+        if count >= 3 {
+            break
+        }
+        fmt.Println("无限循环:", count)
+    }
+
+    // 遍历切片
+    slice := []string{"a", "b", "c"}
+    for index, value := range slice {
+        fmt.Println(index, value)
+    }
+}
+```
+
+#### Switch语句示例
+```go
+package main
+
+import (
+    "fmt"
+    "runtime"
+)
+
+func main() {
+    // 基本switch
+    switch os := runtime.GOOS; os {
+    case "darwin":
+        fmt.Println("macOS")
+    case "linux":
+        fmt.Println("Linux")
+    case "windows":
+        fmt.Println("Windows")
+    default:
+        fmt.Printf("%s.\n", os)
+    }
+
+    // 无表达式的switch（类似if/else链）
+    hour := 14
+    switch {
+    case hour < 12:
+        fmt.Println("上午")
+    case hour < 18:
+        fmt.Println("下午")
+    default:
+        fmt.Println("晚上")
+    }
+}
+```
+
+#### Defer示例
+```go
+package main
+
+import "fmt"
+
+func main() {
+    // defer按照后进先出(LIFO)顺序执行
+    defer fmt.Println("世界")
+    defer fmt.Println("你好")
+    
+    fmt.Println("开始")
+    // 输出顺序：开始、你好、世界
+}
+```
 
 ### 1.7 函数
 - 函数定义与调用
 - 多返回值
 - 匿名函数与闭包
 - 函数作为参数
+- 可变参数函数
+- 递归函数
+
+#### 函数定义示例
+```go
+package main
+
+import "fmt"
+
+// 基本函数
+func add(x, y int) int {
+    return x + y
+}
+
+// 多返回值
+func swap(x, y string) (string, string) {
+    return y, x
+}
+
+// 命名返回值
+func split(sum int) (x, y int) {
+    x = sum * 4 / 9
+    y = sum - x
+    return // 直接返回命名的变量
+}
+
+func main() {
+    // 测试基本函数
+    result := add(3, 5)
+    fmt.Println("3 + 5 =", result)
+    
+    // 测试多返回值
+    a, b := swap("hello", "world")
+    fmt.Println("交换后:", a, b)
+    
+    // 测试命名返回值
+    x, y := split(17)
+    fmt.Println("分割结果:", x, y)
+}
+```
+
+#### 可变参数函数
+```go
+package main
+
+import "fmt"
+
+func sum(nums ...int) int {
+    total := 0
+    for _, num := range nums {
+        total += num
+    }
+    return total
+}
+
+func main() {
+    // 调用
+    fmt.Println(sum(1, 2))      // 3
+    fmt.Println(sum(1, 2, 3))   // 6
+    fmt.Println(sum(1, 2, 3, 4, 5)) // 15
+}
+```
+
+#### 闭包示例
+```go
+package main
+
+import "fmt"
+
+// 闭包函数
+func adder() func(int) int {
+    sum := 0
+    return func(x int) int {
+        sum += x
+        return sum
+    }
+}
+
+func main() {
+    // 使用
+    pos, neg := adder(), adder()
+    for i := 0; i < 5; i++ {
+        fmt.Println(
+            pos(i),     // 0 1 3 6 10...
+            neg(-2*i),  // 0 -2 -6 -12 -20...
+        )
+    }
+}
+```
+
+#### 递归函数
+```go
+package main
+
+import "fmt"
+
+// 阶乘计算
+func factorial(n int) int {
+    if n == 0 {
+        return 1
+    }
+    return n * factorial(n-1)
+}
+
+// 斐波那契数列
+func fib(n int) int {
+    if n < 2 {
+        return n
+    }
+    return fib(n-1) + fib(n-2)
+}
+
+func main() {
+    // 测试阶乘
+    fmt.Println("5! =", factorial(5))
+    
+    // 测试斐波那契数列
+    for i := 0; i < 10; i++ {
+        fmt.Printf("fib(%d) = %d\n", i, fib(i))
+    }
+}
+```
 
 ## 练习项目
 
 ### 项目1：基础计算器
 ```go
+package main
+
+import (
+    "fmt"
+    "strconv"
+    "strings"
+)
+
 // 实现加减乘除运算
-func calculator(a, b float64, operator string) float64 {
-    // 实现逻辑
+func calculator(a, b float64, operator string) (float64, error) {
+    switch operator {
+    case "+":
+        return a + b, nil
+    case "-":
+        return a - b, nil
+    case "*":
+        return a * b, nil
+    case "/":
+        if b == 0 {
+            return 0, fmt.Errorf("除数不能为零")
+        }
+        return a / b, nil
+    default:
+        return 0, fmt.Errorf("不支持的运算符: %s", operator)
+    }
+}
+
+// 扩展功能：支持表达式解析
+func evaluateExpression(expr string) (float64, error) {
+    // 简单实现：只支持两个数的运算
+    expr = strings.ReplaceAll(expr, " ", "")
+    
+    // 查找运算符
+    var operator string
+    var index int
+    for i, c := range expr {
+        if c == '+' || c == '-' || c == '*' || c == '/' {
+            operator = string(c)
+            index = i
+            break
+        }
+    }
+    
+    if operator == "" {
+        return 0, fmt.Errorf("无效的表达式")
+    }
+    
+    // 提取两个数字
+    num1Str := expr[:index]
+    num2Str := expr[index+1:]
+    
+    num1, err := strconv.ParseFloat(num1Str, 64)
+    if err != nil {
+        return 0, fmt.Errorf("无效的数字: %s", num1Str)
+    }
+    
+    num2, err := strconv.ParseFloat(num2Str, 64)
+    if err != nil {
+        return 0, fmt.Errorf("无效的数字: %s", num2Str)
+    }
+    
+    return calculator(num1, num2, operator)
+}
+
+func main() {
+    // 测试基本计算
+    result, err := calculator(10, 5, "+")
+    if err != nil {
+        fmt.Println("错误:", err)
+    } else {
+        fmt.Println("10 + 5 =", result)
+    }
+    
+    // 测试表达式解析
+    expr := "3.5 * 2"
+    result, err = evaluateExpression(expr)
+    if err != nil {
+        fmt.Println("错误:", err)
+    } else {
+        fmt.Printf("%s = %.2f\n", expr, result)
+    }
 }
 ```
 
 ### 项目2：温度转换器
 ```go
+package main
+
+import (
+    "fmt"
+    "strings"
+)
+
 // 摄氏温度与华氏温度转换
-func celsiusToFahrenheit(c float64) float64
-func fahrenheitToCelsius(f float64) float64
+func celsiusToFahrenheit(c float64) float64 {
+    return c*9/5 + 32
+}
+
+func fahrenheitToCelsius(f float64) float64 {
+    return (f - 32) * 5 / 9
+}
+
+// 摄氏温度与开尔文温度转换
+func celsiusToKelvin(c float64) float64 {
+    return c + 273.15
+}
+
+func kelvinToCelsius(k float64) float64 {
+    return k - 273.15
+}
+
+// 扩展：支持多种温度单位转换
+type Temperature struct {
+    Value float64
+    Unit  string // "C", "F", "K"
+}
+
+func ConvertTemperature(temp Temperature, targetUnit string) (Temperature, error) {
+    // 先转换为摄氏温度
+    var celsius float64
+    switch strings.ToUpper(temp.Unit) {
+    case "C":
+        celsius = temp.Value
+    case "F":
+        celsius = fahrenheitToCelsius(temp.Value)
+    case "K":
+        celsius = kelvinToCelsius(temp.Value)
+    default:
+        return Temperature{}, fmt.Errorf("不支持的温度单位: %s", temp.Unit)
+    }
+    
+    // 从摄氏温度转换为目标单位
+    var result float64
+    switch strings.ToUpper(targetUnit) {
+    case "C":
+        result = celsius
+    case "F":
+        result = celsiusToFahrenheit(celsius)
+    case "K":
+        result = celsiusToKelvin(celsius)
+    default:
+        return Temperature{}, fmt.Errorf("不支持的目标温度单位: %s", targetUnit)
+    }
+    
+    return Temperature{Value: result, Unit: strings.ToUpper(targetUnit)}, nil
+}
+
+func main() {
+    // 测试基本转换
+    c := 25.0
+    f := celsiusToFahrenheit(c)
+    fmt.Printf("%.2f°C = %.2f°F\n", c, f)
+    
+    f = 77.0
+    c = fahrenheitToCelsius(f)
+    fmt.Printf("%.2f°F = %.2f°C\n", f, c)
+    
+    // 测试多种温度单位转换
+    temp := Temperature{Value: 100, Unit: "C"}
+    
+    targets := []string{"F", "K"}
+    for _, target := range targets {
+        converted, err := ConvertTemperature(temp, target)
+        if err != nil {
+            fmt.Println("错误:", err)
+        } else {
+            fmt.Printf("%.2f%s = %.2f%s\n", temp.Value, temp.Unit, converted.Value, converted.Unit)
+        }
+    }
+}
 ```
 
 ### 项目3：文本统计工具
 ```go
+package main
+
+import (
+    "fmt"
+    "sort"
+    "strings"
+)
+
 // 统计文本中的字符数、单词数、行数
-func textStats(text string) (chars, words, lines int)
+func textStats(text string) (chars, words, lines int) {
+    chars = len(text)
+    words = len(strings.Fields(text))
+    lines = strings.Count(text, "\n") + 1
+    return
+}
+
+// 扩展功能：词频统计
+func wordFrequency(text string) map[string]int {
+    words := strings.Fields(strings.ToLower(text))
+    freq := make(map[string]int)
+    for _, word := range words {
+        // 去除标点符号
+        cleanWord := strings.Trim(word, ".,!?;:\"'")
+        if cleanWord != "" {
+            freq[cleanWord]++
+        }
+    }
+    return freq
+}
+
+// 扩展功能：查找最长单词
+func longestWord(text string) string {
+    words := strings.Fields(text)
+    longest := ""
+    for _, word := range words {
+        cleanWord := strings.Trim(word, ".,!?;:\"'")
+        if len(cleanWord) > len(longest) {
+            longest = cleanWord
+        }
+    }
+    return longest
+}
+
+// 按频率排序单词
+func sortWordsByFrequency(freq map[string]int) []string {
+    type wordFreq struct {
+        word  string
+        count int
+    }
+    
+    var wordFreqs []wordFreq
+    for word, count := range freq {
+        wordFreqs = append(wordFreqs, wordFreq{word, count})
+    }
+    
+    sort.Slice(wordFreqs, func(i, j int) bool {
+        return wordFreqs[i].count > wordFreqs[j].count
+    })
+    
+    var result []string
+    for _, wf := range wordFreqs {
+        result = append(result, fmt.Sprintf("%s: %d", wf.word, wf.count))
+    }
+    
+    return result
+}
+
+func main() {
+    text := `Go is an open source programming language that makes it easy to build simple,
+reliable, and efficient software. Go is developed by Google.`
+    
+    // 基本统计
+    chars, words, lines := textStats(text)
+    fmt.Printf("字符数: %d, 单词数: %d, 行数: %d\n", chars, words, lines)
+    
+    // 词频统计
+    freq := wordFrequency(text)
+    fmt.Println("\n词频统计:")
+    sortedWords := sortWordsByFrequency(freq)
+    for _, wordCount := range sortedWords {
+        fmt.Println(wordCount)
+    }
+    
+    // 最长单词
+    longest := longestWord(text)
+    fmt.Printf("\n最长单词: %s\n", longest)
+}
+```
+
+### 项目4：猜数字游戏
+```go
+package main
+
+import (
+    "bufio"
+    "fmt"
+    "math/rand"
+    "os"
+    "strconv"
+    "time"
+)
+
+func playGuessingGame() {
+    // 初始化随机数种子
+    rand.Seed(time.Now().UnixNano())
+    
+    // 生成1-100的随机数
+    target := rand.Intn(100) + 1
+    var guess int
+    attempts := 0
+    
+    fmt.Println("猜一个1到100之间的数字")
+    
+    reader := bufio.NewReader(os.Stdin)
+    
+    for {
+        fmt.Print("请输入你的猜测: ")
+        input, _ := reader.ReadString('\n')
+        input = strings.TrimSpace(input)
+        
+        num, err := strconv.Atoi(input)
+        if err != nil {
+            fmt.Println("请输入有效的数字!")
+            continue
+        }
+        
+        guess = num
+        attempts++
+        
+        if guess < target {
+            fmt.Println("太小了!")
+        } else if guess > target {
+            fmt.Println("太大了!")
+        } else {
+            fmt.Printf("恭喜! 你用%d次猜中了数字%d\n", attempts, target)
+            break
+        }
+    }
+}
+
+func main() {
+    playGuessingGame()
+}
+```
+
+### 项目5：简单通讯录
+```go
+package main
+
+import (
+    "bufio"
+    "fmt"
+    "os"
+    "strings"
+)
+
+type Contact struct {
+    Name    string
+    Phone   string
+    Email   string
+    Address string
+}
+
+type AddressBook struct {
+    contacts []Contact
+}
+
+func (ab *AddressBook) AddContact(contact Contact) {
+    ab.contacts = append(ab.contacts, contact)
+}
+
+func (ab *AddressBook) FindContact(name string) *Contact {
+    for i, contact := range ab.contacts {
+        if contact.Name == name {
+            return &ab.contacts[i]
+        }
+    }
+    return nil
+}
+
+func (ab *AddressBook) DeleteContact(name string) bool {
+    for i, contact := range ab.contacts {
+        if contact.Name == name {
+            ab.contacts = append(ab.contacts[:i], ab.contacts[i+1:]...)
+            return true
+        }
+    }
+    return false
+}
+
+func (ab *AddressBook) ListContacts() {
+    fmt.Println("通讯录:")
+    for _, contact := range ab.contacts {
+        fmt.Printf("姓名: %s, 电话: %s, 邮箱: %s, 地址: %s\n", 
+            contact.Name, contact.Phone, contact.Email, contact.Address)
+    }
+}
+
+func (ab *AddressBook) UpdateContact(name string, newContact Contact) bool {
+    for i, contact := range ab.contacts {
+        if contact.Name == name {
+            ab.contacts[i] = newContact
+            return true
+        }
+    }
+    return false
+}
+
+func showMenu() {
+    fmt.Println("\n===== 通讯录管理系统 =====")
+    fmt.Println("1. 添加联系人")
+    fmt.Println("2. 查找联系人")
+    fmt.Println("3. 删除联系人")
+    fmt.Println("4. 更新联系人")
+    fmt.Println("5. 显示所有联系人")
+    fmt.Println("6. 退出")
+    fmt.Print("请选择操作: ")
+}
+
+func main() {
+    addressBook := AddressBook{}
+    reader := bufio.NewReader(os.Stdin)
+    
+    for {
+        showMenu()
+        choice, _ := reader.ReadString('\n')
+        choice = strings.TrimSpace(choice)
+        
+        switch choice {
+        case "1":
+            fmt.Println("\n--- 添加联系人 ---")
+            fmt.Print("姓名: ")
+            name, _ := reader.ReadString('\n')
+            name = strings.TrimSpace(name)
+            
+            fmt.Print("电话: ")
+            phone, _ := reader.ReadString('\n')
+            phone = strings.TrimSpace(phone)
+            
+            fmt.Print("邮箱: ")
+            email, _ := reader.ReadString('\n')
+            email = strings.TrimSpace(email)
+            
+            fmt.Print("地址: ")
+            address, _ := reader.ReadString('\n')
+            address = strings.TrimSpace(address)
+            
+            contact := Contact{
+                Name:    name,
+                Phone:   phone,
+                Email:   email,
+                Address: address,
+            }
+            
+            addressBook.AddContact(contact)
+            fmt.Println("联系人添加成功!")
+            
+        case "2":
+            fmt.Print("\n请输入要查找的联系人姓名: ")
+            name, _ := reader.ReadString('\n')
+            name = strings.TrimSpace(name)
+            
+            contact := addressBook.FindContact(name)
+            if contact != nil {
+                fmt.Printf("找到联系人: 姓名: %s, 电话: %s, 邮箱: %s, 地址: %s\n", 
+                    contact.Name, contact.Phone, contact.Email, contact.Address)
+            } else {
+                fmt.Println("未找到该联系人")
+            }
+            
+        case "3":
+            fmt.Print("\n请输入要删除的联系人姓名: ")
+            name, _ := reader.ReadString('\n')
+            name = strings.TrimSpace(name)
+            
+            if addressBook.DeleteContact(name) {
+                fmt.Println("联系人删除成功!")
+            } else {
+                fmt.Println("未找到该联系人")
+            }
+            
+        case "4":
+            fmt.Print("\n请输入要更新的联系人姓名: ")
+            name, _ := reader.ReadString('\n')
+            name = strings.TrimSpace(name)
+            
+            if addressBook.FindContact(name) == nil {
+                fmt.Println("未找到该联系人")
+                continue
+            }
+            
+            fmt.Println("\n--- 更新联系人信息 ---")
+            fmt.Print("新电话: ")
+            phone, _ := reader.ReadString('\n')
+            phone = strings.TrimSpace(phone)
+            
+            fmt.Print("新邮箱: ")
+            email, _ := reader.ReadString('\n')
+            email = strings.TrimSpace(email)
+            
+            fmt.Print("新地址: ")
+            address, _ := reader.ReadString('\n')
+            address = strings.TrimSpace(address)
+            
+            newContact := Contact{
+                Name:    name,
+                Phone:   phone,
+                Email:   email,
+                Address: address,
+            }
+            
+            if addressBook.UpdateContact(name, newContact) {
+                fmt.Println("联系人更新成功!")
+            }
+            
+        case "5":
+            addressBook.ListContacts()
+            
+        case "6":
+            fmt.Println("感谢使用通讯录管理系统，再见!")
+            return
+            
+        default:
+            fmt.Println("无效的选择，请重新输入")
+        }
+    }
+}
 ```
 
 ## 推荐资源
@@ -114,20 +889,110 @@ func textStats(text string) (chars, words, lines int)
 
 ### 时间安排（1-2周）
 - 第1-3天：环境搭建与基础语法
+  - 安装Go开发环境
+  - 学习包声明、导入、主函数
+  - 编写第一个Go程序
+  - 理解Go的项目结构
+
 - 第4-7天：数据类型与控制结构
+  - 掌握基本数据类型和复合类型
+  - 学习变量声明与类型转换
+  - 练习条件语句和循环
+  - 理解switch和defer的使用
+
 - 第8-10天：函数与项目练习
+  - 学习函数定义与调用
+  - 掌握多返回值和可变参数
+  - 理解闭包和递归
+  - 完成计算器和温度转换项目
+
 - 第11-14天：综合练习与复习
+  - 完成文本统计工具
+  - 开发猜数字游戏
+  - 实现简单通讯录
+  - 复习所有知识点并准备进入下一阶段
 
 ## 常见问题
 
 ### Q: Go的包管理如何使用？
-A: 使用go mod init初始化模块，go mod tidy管理依赖
+A: 使用go mod init初始化模块，go mod tidy管理依赖。例如：
+```bash
+go mod init myproject
+go mod tidy  # 下载并整理依赖
+go mod download  # 下载依赖到本地缓存
+```
 
 ### Q: 为什么Go只有for循环？
-A: Go设计哲学强调简洁，for循环足够灵活
+A: Go设计哲学强调简洁，for循环足够灵活。Go的for循环可以：
+- 替代传统的for循环
+- 替代while循环
+- 替代do-while循环
+- 遍历数据结构
 
 ### Q: defer的执行顺序？
-A: defer语句按照后进先出(LIFO)的顺序执行
+A: defer语句按照后进先出(LIFO)的顺序执行。多个defer语句会压入栈中，函数返回时按相反顺序执行。
+
+### Q: Go中的nil和空字符串有什么区别？
+A: nil表示"无值"，适用于指针、切片、映射、函数、接口和通道；空字符串""是一个有效的字符串值，长度为0。
+
+### Q: 切片和数组的区别？
+A: 数组是固定长度的值类型，切片是动态长度的引用类型。切片底层依赖数组，但可以自动扩容。
+
+### Q: 如何理解Go的闭包？
+A: 闭包是一个函数值，它引用了函数体之外的变量。该函数可以访问并赋予其引用的变量的值。
+
+### Q: Go的错误处理方式？
+A: Go使用多返回值处理错误，通常函数返回一个结果和一个error类型值。error为nil表示成功，非nil表示失败。
+
+### Q: :=和var声明有什么区别？
+A: :=是短变量声明，只能在函数内部使用，自动类型推断；var是完整声明，可在任何地方使用，需要显式指定类型或提供初始值。
+
+### Q: Go的命名规范？
+A: 
+- 公开名称（首字母大写）可被其他包访问
+- 私有名称（首字母小写）只能在包内访问
+- 使用驼峰命名法，不使用下划线
+- 常量通常全大写，用下划线分隔
+
+## 学习建议
+
+### 1. 实践为主
+- 每个知识点都要编写代码验证
+- 不要只看不练，动手实践是学习Go的关键
+- 尝试修改示例代码，观察结果变化
+
+### 2. 循序渐进
+- 先掌握基础语法，再深入特性
+- 不要急于求成，扎实基础更重要
+- 遇到问题及时查阅官方文档
+
+### 3. 代码规范
+- 养成良好的命名习惯
+- 添加必要的注释
+- 使用gofmt格式化代码
+
+### 4. 调试技巧
+- 学会使用fmt.Println进行简单调试
+- 了解Go的panic和recover机制
+- 尝试使用Delve等调试工具
+
+## 自我检测
+
+完成本阶段学习后，尝试回答以下问题：
+
+1. Go语言的主要特点是什么？
+2. 如何声明和使用不同类型的变量？
+3. for循环有哪些不同的使用方式？
+4. 函数如何返回多个值？
+5. 什么是闭包？它有什么用途？
+6. 切片和数组有什么区别？
+7. defer语句的执行顺序是怎样的？
+8. 如何处理Go中的错误？
 
 ## 下一步
-完成本阶段学习后，进入第二阶段：核心概念学习
+完成本阶段学习后，进入第二阶段：核心概念学习，包括：
+- 指针深入理解
+- 结构体与方法
+- 接口与多态
+- 错误处理机制
+- 并发编程基础

docs/phase2-core.md

@@ -10,44 +10,104 @@
 
 ### 2.1 指针与内存管理
 ```go
-// 指针基础
-var x int = 10
-var p *int = &x
-*p = 20 // 修改x的值
-
-// new函数分配内存
-ptr := new(int)
-*ptr = 100
+package main
+
+import "fmt"
+
+func main() {
+    // 指针基础
+    var x int = 10
+    var p *int = &x
+    fmt.Printf("x的值: %d, x的地址: %p\n", x, &x)
+    fmt.Printf("p存储的地址: %p, p指向的值: %d\n", p, *p)
+    
+    *p = 20 // 修改x的值
+    fmt.Printf("修改后x的值: %d\n", x)
+    
+    // new函数分配内存
+    ptr := new(int)
+    *ptr = 100
+    fmt.Printf("new分配的内存地址: %p, 值: %d\n", ptr, *ptr)
+    
+    // 指针作为函数参数
+    changeValue(&x)
+    fmt.Printf("函数调用后x的值: %d\n", x)
+}
+
+func changeValue(p *int) {
+    *p = 50
+}
 ```
 
 ### 2.2 结构体与方法
 ```go
+package main
+
+import "fmt"
+
 // 结构体定义
 type Person struct {
     Name string
     Age  int
 }
 
-// 方法定义
+// 构造函数
+func NewPerson(name string, age int) *Person {
+    return &Person{
+        Name: name,
+        Age:  age,
+    }
+}
+
+// 值接收者方法
 func (p Person) SayHello() string {
     return "Hello, " + p.Name
 }
 
-// 指针接收者
+// 指针接收者方法
 func (p *Person) SetAge(age int) {
     p.Age = age
 }
+
+func (p *Person) HaveBirthday() {
+    p.Age++
+    fmt.Printf("%s 过生日了，现在 %d 岁\n", p.Name, p.Age)
+}
+
+func main() {
+    // 创建结构体实例
+    p1 := Person{Name: "张三", Age: 25}
+    fmt.Println(p1.SayHello())
+    
+    // 使用构造函数
+    p2 := NewPerson("李四", 30)
+    fmt.Println(p2.SayHello())
+    
+    // 使用指针方法修改值
+    p2.SetAge(32)
+    fmt.Printf("%s 现在 %d 岁\n", p2.Name, p2.Age)
+    
+    // 调用修改状态的方法
+    p2.HaveBirthday()
+}
 ```
 
 ### 2.3 接口与多态
 ```go
+package main
+
+import (
+    "fmt"
+    "math"
+)
+
 // 接口定义
 type Shape interface {
     Area() float64
     Perimeter() float64
 }
 
-// 实现接口
+// 实现接口 - 矩形
 type Rectangle struct {
     Width, Height float64
 }
@@ -59,10 +119,75 @@ func (r Rectangle) Area() float64 {
 func (r Rectangle) Perimeter() float64 {
     return 2 * (r.Width + r.Height)
 }
+
+// 实现接口 - 圆形
+type Circle struct {
+    Radius float64
+}
+
+func (c Circle) Area() float64 {
+    return math.Pi * c.Radius * c.Radius
+}
+
+func (c Circle) Perimeter() float64 {
+    return 2 * math.Pi * c.Radius
+}
+
+// 实现接口 - 三角形
+type Triangle struct {
+    Base, Height float64
+}
+
+func (t Triangle) Area() float64 {
+    return 0.5 * t.Base * t.Height
+}
+
+func (t Triangle) Perimeter() float64 {
+    // 假设是等腰三角形
+    side := math.Sqrt(t.Base*t.Base/4 + t.Height*t.Height)
+    return t.Base + 2*side
+}
+
+// 多态函数
+func PrintShapeInfo(s Shape) {
+    fmt.Printf("形状面积: %.2f, 周长: %.2f\n", s.Area(), s.Perimeter())
+}
+
+func main() {
+    // 创建不同的形状
+    shapes := []Shape{
+        Rectangle{Width: 5, Height: 3},
+        Circle{Radius: 4},
+        Triangle{Base: 6, Height: 4},
+    }
+    
+    // 多态调用
+    for i, shape := range shapes {
+        fmt.Printf("形状 %d: ", i+1)
+        PrintShapeInfo(shape)
+    }
+    
+    // 类型断言
+    for _, shape := range shapes {
+        if rect, ok := shape.(Rectangle); ok {
+            fmt.Printf("矩形的宽: %.2f, 高: %.2f\n", rect.Width, rect.Height)
+        } else if circle, ok := shape.(Circle); ok {
+            fmt.Printf("圆形的半径: %.2f\n", circle.Radius)
+        }
+    }
+}
 ```
 
 ### 2.4 错误处理
 ```go
+package main
+
+import (
+    "errors"
+    "fmt"
+    "strconv"
+)
+
 // 错误处理模式
 func divide(a, b float64) (float64, error) {
     if b == 0 {
@@ -80,25 +205,203 @@ type MyError struct {
 func (e MyError) Error() string {
     return fmt.Sprintf("Error %d: %s", e.Code, e.Message)
 }
+
+// 使用自定义错误的函数
+func processValue(value int) (string, error) {
+    if value < 0 {
+        return "", MyError{Code: 400, Message: "值不能为负数"}
+    }
+    if value > 100 {
+        return "", MyError{Code: 413, Message: "值超出范围"}
+    }
+    return "处理成功: " + strconv.Itoa(value), nil
+}
+
+// 错误包装
+func wrapError(value string) (int, error) {
+    num, err := strconv.Atoi(value)
+    if err != nil {
+        return 0, fmt.Errorf("转换失败: %w", err)
+    }
+    return num, nil
+}
+
+func main() {
+    // 测试基本错误处理
+    result, err := divide(10, 2)
+    if err != nil {
+        fmt.Println("错误:", err)
+    } else {
+        fmt.Println("结果:", result)
+    }
+    
+    // 测试除零错误
+    _, err = divide(10, 0)
+    if err != nil {
+        fmt.Println("错误:", err)
+    }
+    
+    // 测试自定义错误
+    values := []int{50, -5, 150}
+    for _, v := range values {
+        result, err := processValue(v)
+        if err != nil {
+            // 类型断言获取自定义错误
+            if myErr, ok := err.(MyError); ok {
+                fmt.Printf("自定义错误 - 代码: %d, 消息: %s\n", myErr.Code, myErr.Message)
+            } else {
+                fmt.Println("其他错误:", err)
+            }
+        } else {
+            fmt.Println(result)
+        }
+    }
+    
+    // 测试错误包装
+    inputs := []string{"123", "abc", "45.6"}
+    for _, input := range inputs {
+        num, err := wrapError(input)
+        if err != nil {
+            fmt.Printf("输入 '%s' 转换失败: %v\n", input, err)
+        } else {
+            fmt.Printf("转换成功: %d\n", num)
+        }
+    }
+}
 ```
 
 ### 2.5 并发编程基础
 ```go
-// goroutine
-func sayHello() {
-    fmt.Println("Hello from goroutine")
+package main
+
+import (
+    "fmt"
+    "sync"
+    "time"
+)
+
+// goroutine示例
+func sayHello(name string) {
+    for i := 0; i < 3; i++ {
+        fmt.Printf("你好, %s! (第%d次)\n", name, i+1)
+        time.Sleep(100 * time.Millisecond)
+    }
 }
 
-go sayHello() // 启动goroutine
+// channel通信示例
+func channelDemo() {
+    fmt.Println("\n=== Channel通信示例 ===")
+    
+    // 创建无缓冲channel
+    ch := make(chan int)
+    
+    // 启动发送数据的goroutine
+    go func() {
+        for i := 0; i < 5; i++ {
+            fmt.Printf("发送: %d\n", i)
+            ch <- i
+            time.Sleep(200 * time.Millisecond)
+        }
+        close(ch) // 关闭channel
+    }()
+    
+    // 接收数据
+    for value := range ch {
+        fmt.Printf("接收: %d\n", value)
+    }
+}
 
-// channel通信
-ch := make(chan int)
+// 缓冲channel示例
+func bufferedChannelDemo() {
+    fmt.Println("\n=== 缓冲Channel示例 ===")
+    
+    // 创建缓冲channel
+    ch := make(chan string, 3)
+    
+    // 发送数据（不需要立即接收）
+    ch <- "消息1"
+    ch <- "消息2"
+    ch <- "消息3"
+    
+    fmt.Println("已发送3条消息到缓冲channel")
+    
+    // 接收数据
+    fmt.Println(<-ch)
+    fmt.Println(<-ch)
+    fmt.Println(<-ch)
+}
+
+// 使用WaitGroup等待多个goroutine
+func waitGroupDemo() {
+    fmt.Println("\n=== WaitGroup示例 ===")
+    
+    var wg sync.WaitGroup
+    
+    for i := 1; i <= 3; i++ {
+        wg.Add(1)
+        go func(id int) {
+            defer wg.Done()
+            fmt.Printf("Goroutine %d 开始工作\n", id)
+            time.Sleep(time.Duration(id) * 200 * time.Millisecond)
+            fmt.Printf("Goroutine %d 完成工作\n", id)
+        }(i)
+    }
+    
+    fmt.Println("等待所有goroutine完成...")
+    wg.Wait()
+    fmt.Println("所有goroutine已完成")
+}
 
-go func() {
-    ch <- 42 // 发送数据
-}()
+// select语句示例
+func selectDemo() {
+    fmt.Println("\n=== Select语句示例 ===")
+    
+    ch1 := make(chan string)
+    ch2 := make(chan string)
+    
+    go func() {
+        time.Sleep(1 * time.Second)
+        ch1 <- "来自channel 1的消息"
+    }()
+    
+    go func() {
+        time.Sleep(2 * time.Second)
+        ch2 <- "来自channel 2的消息"
+    }()
+    
+    for i := 0; i < 2; i++ {
+        select {
+        case msg1 := <-ch1:
+            fmt.Println(msg1)
+        case msg2 := <-ch2:
+            fmt.Println(msg2)
+        case <-time.After(3 * time.Second):
+            fmt.Println("超时!")
+        }
+    }
+}
 
-value := <-ch // 接收数据
+func main() {
+    // 启动多个goroutine
+    fmt.Println("=== Goroutine示例 ===")
+    go sayHello("张三")
+    go sayHello("李四")
+    
+    // 等待一段时间让goroutine执行
+    time.Sleep(1 * time.Second)
+    
+    // 演示channel通信
+    channelDemo()
+    
+    // 演示缓冲channel
+    bufferedChannelDemo()
+    
+    // 演示WaitGroup
+    waitGroupDemo()
+    
+    // 演示select
+    selectDemo()
+}
 ```
 
 ### 2.6 包管理与模块化
@@ -114,10 +417,123 @@ require (
 )
 ```
 
+#### 包管理示例
+
+创建以下目录结构：
+```
+myproject/
+├── go.mod
+├── main.go
+└── calculator/
+    ├── add.go
+    └── subtract.go
+```
+
+**calculator/add.go**
+```go
+package calculator
+
+// Add 返回两个整数的和
+func Add(a, b int) int {
+    return a + b
+}
+
+// AddMultiple 返回多个整数的和
+func AddMultiple(nums ...int) int {
+    sum := 0
+    for _, num := range nums {
+        sum += num
+    }
+    return sum
+}
+```
+
+**calculator/subtract.go**
+```go
+package calculator
+
+// Subtract 返回两个整数的差
+func Subtract(a, b int) int {
+    return a - b
+}
+
+// SubtractMultiple 从第一个数中减去后续所有数
+func SubtractMultiple(first int, nums ...int) int {
+    result := first
+    for _, num := range nums {
+        result -= num
+    }
+    return result
+}
+```
+
+**main.go**
+```go
+package main
+
+import (
+    "fmt"
+    
+    "github.com/username/project/calculator"
+)
+
+func main() {
+    // 使用自定义包中的函数
+    sum := calculator.Add(10, 20)
+    fmt.Printf("10 + 20 = %d\n", sum)
+    
+    diff := calculator.Subtract(30, 15)
+    fmt.Printf("30 - 15 = %d\n", diff)
+    
+    multipleSum := calculator.AddMultiple(1, 2, 3, 4, 5)
+    fmt.Printf("1 + 2 + 3 + 4 + 5 = %d\n", multipleSum)
+    
+    multipleDiff := calculator.SubtractMultiple(100, 10, 20, 30)
+    fmt.Printf("100 - 10 - 20 - 30 = %d\n", multipleDiff)
+}
+```
+
+#### 模块化最佳实践
+
+1. **包命名规范**
+   - 使用简短、小写的名称
+   - 避免使用下划线或混合大小写
+   - 包名应与目录名一致
+
+2. **可见性规则**
+   - 首字母大写的名称是公开的（可被其他包访问）
+   - 首字母小写的名称是私有的（只能在包内访问）
+
+3. **依赖管理**
+   ```bash
+   # 初始化模块
+   go mod init github.com/username/project
+   
+   # 添加依赖
+   go get github.com/gin-gonic/gin
+   
+   # 整理依赖
+   go mod tidy
+   
+   # 下载依赖
+   go mod download
+   
+   # 查看依赖图
+   go mod graph
+   ```
+
 ## 练习项目
 
 ### 项目1：学生信息管理系统
 ```go
+package main
+
+import (
+    "fmt"
+    "sort"
+)
+
+// 学生结构体
 type Student struct {
     ID    int
     Name  string
@@ -125,52 +541,612 @@ type Student struct {
     Score float64
 }
 
-// 实现增删改查功能
+// 学生管理器
 type StudentManager struct {
     students []Student
+    nextID   int
+}
+
+// 创建新的学生管理器
+func NewStudentManager() *StudentManager {
+    return &StudentManager{
+        students: make([]Student, 0),
+        nextID:   1,
+    }
+}
+
+// 添加学生
+func (sm *StudentManager) AddStudent(name string, grade int, score float64) error {
+    if name == "" {
+        return fmt.Errorf("学生姓名不能为空")
+    }
+    if grade < 1 || grade > 12 {
+        return fmt.Errorf("年级必须在1-12之间")
+    }
+    if score < 0 || score > 100 {
+        return fmt.Errorf("分数必须在0-100之间")
+    }
+    
+    student := Student{
+        ID:    sm.nextID,
+        Name:  name,
+        Grade: grade,
+        Score: score,
+    }
+    
+    sm.students = append(sm.students, student)
+    sm.nextID++
+    
+    fmt.Printf("成功添加学生: %s (ID: %d)\n", name, student.ID)
+    return nil
 }
 
-func (sm *StudentManager) AddStudent(s Student) error
-func (sm *StudentManager) FindStudentByID(id int) (Student, error)
-func (sm *StudentManager) UpdateStudent(s Student) error
-func (sm *StudentManager) DeleteStudent(id int) error
+// 根据ID查找学生
+func (sm *StudentManager) FindStudentByID(id int) (Student, error) {
+    for _, student := range sm.students {
+        if student.ID == id {
+            return student, nil
+        }
+    }
+    return Student{}, fmt.Errorf("未找到ID为%d的学生", id)
+}
+
+// 更新学生信息
+func (sm *StudentManager) UpdateStudent(id int, name string, grade int, score float64) error {
+    for i, student := range sm.students {
+        if student.ID == id {
+            if name != "" {
+                sm.students[i].Name = name
+            }
+            if grade >= 1 && grade <= 12 {
+                sm.students[i].Grade = grade
+            }
+            if score >= 0 && score <= 100 {
+                sm.students[i].Score = score
+            }
+            fmt.Printf("成功更新学生信息 (ID: %d)\n", id)
+            return nil
+        }
+    }
+    return fmt.Errorf("未找到ID为%d的学生", id)
+}
+
+// 删除学生
+func (sm *StudentManager) DeleteStudent(id int) error {
+    for i, student := range sm.students {
+        if student.ID == id {
+            sm.students = append(sm.students[:i], sm.students[i+1:]...)
+            fmt.Printf("成功删除学生: %s (ID: %d)\n", student.Name, id)
+            return nil
+        }
+    }
+    return fmt.Errorf("未找到ID为%d的学生", id)
+}
+
+// 列出所有学生
+func (sm *StudentManager) ListAllStudents() {
+    if len(sm.students) == 0 {
+        fmt.Println("暂无学生信息")
+        return
+    }
+    
+    fmt.Println("所有学生信息:")
+    fmt.Println("ID\t姓名\t年级\t分数")
+    for _, student := range sm.students {
+        fmt.Printf("%d\t%s\t%d\t%.1f\n", student.ID, student.Name, student.Grade, student.Score)
+    }
+}
+
+// 按分数排序
+func (sm *StudentManager) SortByScore(descending bool) {
+    sort.Slice(sm.students, func(i, j int) bool {
+        if descending {
+            return sm.students[i].Score > sm.students[j].Score
+        }
+        return sm.students[i].Score < sm.students[j].Score
+    })
+}
+
+// 计算平均分
+func (sm *StudentManager) CalculateAverageScore() float64 {
+    if len(sm.students) == 0 {
+        return 0
+    }
+    
+    total := 0.0
+    for _, student := range sm.students {
+        total += student.Score
+    }
+    return total / float64(len(sm.students))
+}
+
+// 按年级筛选
+func (sm *StudentManager) FilterByGrade(grade int) []Student {
+    var filtered []Student
+    for _, student := range sm.students {
+        if student.Grade == grade {
+            filtered = append(filtered, student)
+        }
+    }
+    return filtered
+}
+
+func main() {
+    // 创建学生管理器
+    manager := NewStudentManager()
+    
+    // 添加学生
+    manager.AddStudent("张三", 10, 85.5)
+    manager.AddStudent("李四", 11, 92.0)
+    manager.AddStudent("王五", 10, 78.5)
+    manager.AddStudent("赵六", 12, 95.5)
+    
+    // 列出所有学生
+    manager.ListAllStudents()
+    
+    // 查找学生
+    student, err := manager.FindStudentByID(2)
+    if err != nil {
+        fmt.Println("错误:", err)
+    } else {
+        fmt.Printf("\n找到学生: %+v\n", student)
+    }
+    
+    // 更新学生信息
+    err = manager.UpdateStudent(2, "李四华", 11, 93.5)
+    if err != nil {
+        fmt.Println("错误:", err)
+    }
+    
+    // 按分数降序排序
+    manager.SortByScore(true)
+    fmt.Println("\n按分数降序排序:")
+    manager.ListAllStudents()
+    
+    // 计算平均分
+    avg := manager.CalculateAverageScore()
+    fmt.Printf("\n所有学生的平均分: %.2f\n", avg)
+    
+    // 按年级筛选
+    grade10Students := manager.FilterByGrade(10)
+    fmt.Println("\n10年级学生:")
+    for _, student := range grade10Students {
+        fmt.Printf("%s: %.1f分\n", student.Name, student.Score)
+    }
+    
+    // 删除学生
+    err = manager.DeleteStudent(3)
+    if err != nil {
+        fmt.Println("错误:", err)
+    }
+    
+    // 再次列出所有学生
+    fmt.Println("\n删除后的学生列表:")
+    manager.ListAllStudents()
+}
 ```
 
 ### 项目2：并发文件下载器
 ```go
-// 使用goroutine并发下载多个文件
-func DownloadFiles(urls []string) error {
+package main
+
+import (
+    "fmt"
+    "io"
+    "net/http"
+    "os"
+    "path/filepath"
+    "sync"
+    "time"
+)
+
+// 下载结果
+type DownloadResult struct {
+    URL      string
+    FilePath string
+    Error    error
+    Size     int64
+    Duration time.Duration
+}
+
+// 下载单个文件
+func downloadFile(url, outputDir string, resultChan chan<- DownloadResult, wg *sync.WaitGroup) {
+    defer wg.Done()
+    
+    startTime := time.Now()
+    
+    // 获取文件名
+    fileName := filepath.Base(url)
+    if fileName == "." || fileName == "/" {
+        fileName = "downloaded_file"
+    }
+    
+    filePath := filepath.Join(outputDir, fileName)
+    
+    // 创建输出目录
+    if err := os.MkdirAll(outputDir, 0755); err != nil {
+        resultChan <- DownloadResult{
+            URL:      url,
+            FilePath: "",
+            Error:    fmt.Errorf("创建目录失败: %v", err),
+            Size:     0,
+            Duration: time.Since(startTime),
+        }
+        return
+    }
+    
+    // 创建文件
+    file, err := os.Create(filePath)
+    if err != nil {
+        resultChan <- DownloadResult{
+            URL:      url,
+            FilePath: "",
+            Error:    fmt.Errorf("创建文件失败: %v", err),
+            Size:     0,
+            Duration: time.Since(startTime),
+        }
+        return
+    }
+    defer file.Close()
+    
+    // 发送HTTP请求
+    resp, err := http.Get(url)
+    if err != nil {
+        resultChan <- DownloadResult{
+            URL:      url,
+            FilePath: "",
+            Error:    fmt.Errorf("下载失败: %v", err),
+            Size:     0,
+            Duration: time.Since(startTime),
+        }
+        return
+    }
+    defer resp.Body.Close()
+    
+    // 检查响应状态
+    if resp.StatusCode != http.StatusOK {
+        resultChan <- DownloadResult{
+            URL:      url,
+            FilePath: "",
+            Error:    fmt.Errorf("服务器返回错误状态码: %d", resp.StatusCode),
+            Size:     0,
+            Duration: time.Since(startTime),
+        }
+        return
+    }
+    
+    // 复制数据到文件
+    size, err := io.Copy(file, resp.Body)
+    if err != nil {
+        resultChan <- DownloadResult{
+            URL:      url,
+            FilePath: "",
+            Error:    fmt.Errorf("写入文件失败: %v", err),
+            Size:     0,
+            Duration: time.Since(startTime),
+        }
+        return
+    }
+    
+    // 发送成功结果
+    resultChan <- DownloadResult{
+        URL:      url,
+        FilePath: filePath,
+        Error:    nil,
+        Size:     size,
+        Duration: time.Since(startTime),
+    }
+}
+
+// 并发下载多个文件
+func DownloadFiles(urls []string, outputDir string, maxConcurrency int) []DownloadResult {
+    // 限制并发数
+    semaphore := make(chan struct{}, maxConcurrency)
     var wg sync.WaitGroup
-    errors := make(chan error, len(urls))
+    resultChan := make(chan DownloadResult, len(urls))
     
+    // 启动下载goroutines
     for _, url := range urls {
         wg.Add(1)
         go func(url string) {
             defer wg.Done()
-            if err := downloadFile(url); err != nil {
-                errors <- err
-            }
+            
+            // 获取信号量
+            semaphore <- struct{}{}
+            defer func() { <-semaphore }()
+            
+            downloadFile(url, outputDir, resultChan, &wg)
         }(url)
     }
     
+    // 等待所有下载完成
     wg.Wait()
-    close(errors)
+    close(resultChan)
     
-    // 处理错误
-    return nil
+    // 收集结果
+    var results []DownloadResult
+    for result := range resultChan {
+        results = append(results, result)
+    }
+    
+    return results
+}
+
+// 显示下载进度
+func showProgress(results []DownloadResult) {
+    var totalSize int64
+    var totalTime time.Duration
+    var successCount, failCount int
+    
+    fmt.Println("\n=== 下载结果 ===")
+    for _, result := range results {
+        if result.Error != nil {
+            fmt.Printf("❌ %s: %v\n", result.URL, result.Error)
+            failCount++
+        } else {
+            fmt.Printf("✅ %s -> %s (%.2f KB, 耗时: %v)\n", 
+                result.URL, result.FilePath, float64(result.Size)/1024, result.Duration)
+            totalSize += result.Size
+            totalTime += result.Duration
+            successCount++
+        }
+    }
+    
+    fmt.Printf("\n总计: %d个文件, 成功: %d, 失败: %d\n", len(results), successCount, failCount)
+    fmt.Printf("总大小: %.2f KB, 总耗时: %v\n", float64(totalSize)/1024, totalTime)
+    
+    if successCount > 0 {
+        avgSpeed := float64(totalSize) / totalTime.Seconds() / 1024
+        fmt.Printf("平均下载速度: %.2f KB/s\n", avgSpeed)
+    }
+}
+
+func main() {
+    // 示例URL列表（使用一些公开的测试文件）
+    urls := []string{
+        "https://httpbin.org/bytes/1024",      // 1KB测试文件
+        "https://httpbin.org/bytes/5120",      // 5KB测试文件
+        "https://httpbin.org/uuid",            // UUID文本
+        "https://httpbin.org/ip",               // IP地址
+        "https://httpbin.org/user-agent",       // 用户代理
+    }
+    
+    // 设置输出目录
+    outputDir := "./downloads"
+    
+    // 设置最大并发数
+    maxConcurrency := 3
+    
+    fmt.Printf("开始下载 %d 个文件，最大并发数: %d\n", len(urls), maxConcurrency)
+    
+    // 开始下载
+    start := time.Now()
+    results := DownloadFiles(urls, outputDir, maxConcurrency)
+    totalDuration := time.Since(start)
+    
+    // 显示结果
+    showProgress(results)
+    fmt.Printf("总下载时间: %v\n", totalDuration)
 }
 ```
 
 ### 项目3：简单的聊天服务器
 ```go
-// 使用channel实现消息广播
-type ChatRoom struct {
+package main
+
+import (
+    "bufio"
+    "fmt"
+    "log"
+    "net"
+    "os"
+    "strings"
+    "sync"
+    "time"
+)
+
+// 客户端结构体
+type Client struct {
+    conn     net.Conn
+    name     string
     messages chan string
-    clients  []chan string
 }
 
-func (cr *ChatRoom) Broadcast(message string)
-func (cr *ChatRoom) Join() chan string
+// 聊天室结构体
+type ChatRoom struct {
+    clients    map[*Client]bool
+    register   chan *Client
+    unregister chan *Client
+    broadcast  chan string
+    mutex      sync.RWMutex
+}
+
+// 创建新的聊天室
+func NewChatRoom() *ChatRoom {
+    return &ChatRoom{
+        clients:    make(map[*Client]bool),
+        register:   make(chan *Client),
+        unregister: make(chan *Client),
+        broadcast:  make(chan string),
+    }
+}
+
+// 运行聊天室
+func (cr *ChatRoom) Run() {
+    for {
+        select {
+        case client := <-cr.register:
+            cr.mutex.Lock()
+            cr.clients[client] = true
+            cr.mutex.Unlock()
+            fmt.Printf("客户端 %s 加入聊天室\n", client.name)
+            
+            // 广播欢迎消息
+            cr.broadcast <- fmt.Sprintf("系统: %s 加入了聊天室", client.name)
+            
+        case client := <-cr.unregister:
+            cr.mutex.Lock()
+            if _, ok := cr.clients[client]; ok {
+                delete(cr.clients, client)
+                close(client.messages)
+                fmt.Printf("客户端 %s 离开聊天室\n", client.name)
+                
+                // 广播离开消息
+                cr.broadcast <- fmt.Sprintf("系统: %s 离开了聊天室", client.name)
+            }
+            cr.mutex.Unlock()
+            
+        case message := <-cr.broadcast:
+            cr.mutex.RLock()
+            for client := range cr.clients {
+                select {
+                case client.messages <- message:
+                default:
+                    // 如果客户端消息通道阻塞，跳过
+                    close(client.messages)
+                    delete(cr.clients, client)
+                }
+            }
+            cr.mutex.RUnlock()
+        }
+    }
+}
+
+// 处理客户端连接
+func (cr *ChatRoom) handleClient(client *Client) {
+    // 发送欢迎消息
+    client.messages <- "欢迎来到聊天室!"
+    
+    // 读取客户端消息
+    scanner := bufio.NewScanner(client.conn)
+    for scanner.Scan() {
+        message := scanner.Text()
+        if strings.TrimSpace(message) == "/quit" {
+            break
+        }
+        
+        // 广播消息
+        cr.broadcast <- fmt.Sprintf("%s: %s", client.name, message)
+    }
+    
+    // 客户端断开连接
+    cr.unregister <- client
+    client.conn.Close()
+}
+
+// 启动聊天服务器
+func startServer(port string) {
+    chatRoom := NewChatRoom()
+    go chatRoom.Run()
+    
+    listener, err := net.Listen("tcp", ":"+port)
+    if err != nil {
+        log.Fatalf("无法启动服务器: %v", err)
+    }
+    defer listener.Close()
+    
+    fmt.Printf("聊天服务器启动，监听端口: %s\n", port)
+    
+    for {
+        conn, err := listener.Accept()
+        if err != nil {
+            log.Printf("接受连接错误: %v", err)
+            continue
+        }
+        
+        // 创建新客户端
+        client := &Client{
+            conn:     conn,
+            name:     fmt.Sprintf("用户%d", time.Now().Unix()%1000),
+            messages: make(chan string, 10),
+        }
+        
+        // 注册客户端
+        chatRoom.register <- client
+        
+        // 处理客户端消息
+        go chatRoom.handleClient(client)
+        
+        // 发送消息给客户端
+        go func(c *Client) {
+            for msg := range c.messages {
+                _, err := fmt.Fprintln(c.conn, msg)
+                if err != nil {
+                    break
+                }
+            }
+        }(client)
+    }
+}
+
+// 聊天客户端
+func startClient(serverAddr, name string) {
+    conn, err := net.Dial("tcp", serverAddr)
+    if err != nil {
+        log.Fatalf("无法连接到服务器: %v", err)
+    }
+    defer conn.Close()
+    
+    // 发送客户端名称
+    fmt.Fprintf(conn, "%s\n", name)
+    
+    // 启动接收消息的goroutine
+    go func() {
+        scanner := bufio.NewScanner(conn)
+        for scanner.Scan() {
+            fmt.Println(scanner.Text())
+        }
+    }()
+    
+    // 读取用户输入并发送
+    reader := bufio.NewReader(os.Stdin)
+    for {
+        fmt.Print("输入消息 (/quit 退出): ")
+        text, err := reader.ReadString('\n')
+        if err != nil {
+            break
+        }
+        
+        fmt.Fprintln(conn, text)
+        
+        if strings.TrimSpace(text) == "/quit" {
+            break
+        }
+    }
+}
+
+func main() {
+    if len(os.Args) < 2 {
+        fmt.Println("使用方法:")
+        fmt.Println("  服务器模式: go run chat.go server <port>")
+        fmt.Println("  客户端模式: go run chat.go client <server:port> <name>")
+        return
+    }
+    
+    mode := os.Args[1]
+    
+    switch mode {
+    case "server":
+        if len(os.Args) < 3 {
+            fmt.Println("请指定端口号")
+            return
+        }
+        port := os.Args[2]
+        startServer(port)
+        
+    case "client":
+        if len(os.Args) < 4 {
+            fmt.Println("请指定服务器地址和用户名")
+            return
+        }
+        serverAddr := os.Args[2]
+        name := os.Args[3]
+        startClient(serverAddr, name)
+        
+    default:
+        fmt.Println("无效的模式，请使用 'server' 或 'client'")
+    }
+}
 ```
 
 ## 推荐资源

docs/phase3-practice.md

@@ -10,6 +10,17 @@
 
 ### 3.1 文件I/O操作
 ```go
+package main
+
+import (
+    "bufio"
+    "fmt"
+    "io"
+    "os"
+    "path/filepath"
+    "strings"
+)
+
 // 文件读写
 func readFile(filename string) (string, error) {
     data, err := os.ReadFile(filename)
@@ -19,10 +30,44 @@ func readFile(filename string) (string, error) {
     return string(data), nil
 }
 
+// 按行读取文件
+func readFileByLines(filename string) ([]string, error) {
+    file, err := os.Open(filename)
+    if err != nil {
+        return nil, err
+    }
+    defer file.Close()
+    
+    var lines []string
+    scanner := bufio.NewScanner(file)
+    for scanner.Scan() {
+        lines = append(lines, scanner.Text())
+    }
+    
+    if err := scanner.Err(); err != nil {
+        return nil, err
+    }
+    
+    return lines, nil
+}
+
+// 写入文件
 func writeFile(filename, content string) error {
     return os.WriteFile(filename, []byte(content), 0644)
 }
 
+// 追加内容到文件
+func appendToFile(filename, content string) error {
+    file, err := os.OpenFile(filename, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
+    if err != nil {
+        return err
+    }
+    defer file.Close()
+    
+    _, err = file.WriteString(content)
+    return err
+}
+
 // 目录操作
 func listFiles(dir string) ([]string, error) {
     entries, err := os.ReadDir(dir)
@@ -36,10 +81,146 @@ func listFiles(dir string) ([]string, error) {
     }
     return files, nil
 }
+
+// 递归列出所有文件
+func listAllFiles(dir string) ([]string, error) {
+    var files []string
+    
+    err := filepath.Walk(dir, func(path string, info os.FileInfo, err error) error {
+        if err != nil {
+            return err
+        }
+        if !info.IsDir() {
+            files = append(files, path)
+        }
+        return nil
+    })
+    
+    return files, err
+}
+
+// 复制文件
+func copyFile(src, dst string) error {
+    sourceFile, err := os.Open(src)
+    if err != nil {
+        return err
+    }
+    defer sourceFile.Close()
+    
+    destFile, err := os.Create(dst)
+    if err != nil {
+        return err
+    }
+    defer destFile.Close()
+    
+    _, err = io.Copy(destFile, sourceFile)
+    return err
+}
+
+// 获取文件信息
+func getFileInfo(filename string) (os.FileInfo, error) {
+    return os.Stat(filename)
+}
+
+// 创建目录
+func createDir(dirName string) error {
+    return os.MkdirAll(dirName, 0755)
+}
+
+func main() {
+    // 创建测试目录和文件
+    testDir := "./test_files"
+    createDir(testDir)
+    
+    // 写入测试文件
+    testFile := filepath.Join(testDir, "test.txt")
+    content := "这是测试文件\n包含多行内容\n用于演示文件操作"
+    err := writeFile(testFile, content)
+    if err != nil {
+        fmt.Printf("写入文件错误: %v\n", err)
+        return
+    }
+    
+    // 读取文件
+    data, err := readFile(testFile)
+    if err != nil {
+        fmt.Printf("读取文件错误: %v\n", err)
+        return
+    }
+    fmt.Printf("文件内容:\n%s\n", data)
+    
+    // 按行读取
+    lines, err := readFileByLines(testFile)
+    if err != nil {
+        fmt.Printf("按行读取错误: %v\n", err)
+        return
+    }
+    fmt.Printf("文件行数: %d\n", len(lines))
+    
+    // 追加内容
+    err = appendToFile(testFile, "\n追加的新行")
+    if err != nil {
+        fmt.Printf("追加内容错误: %v\n", err)
+        return
+    }
+    
+    // 列出目录中的文件
+    files, err := listFiles(testDir)
+    if err != nil {
+        fmt.Printf("列出文件错误: %v\n", err)
+        return
+    }
+    fmt.Printf("目录中的文件: %v\n", files)
+    
+    // 获取文件信息
+    info, err := getFileInfo(testFile)
+    if err != nil {
+        fmt.Printf("获取文件信息错误: %v\n", err)
+        return
+    }
+    fmt.Printf("文件大小: %d 字节\n", info.Size())
+    fmt.Printf("文件修改时间: %v\n", info.ModTime())
+    
+    // 复制文件
+    copyFile := filepath.Join(testDir, "test_copy.txt")
+    err = copyFile(testFile, copyFile)
+    if err != nil {
+        fmt.Printf("复制文件错误: %v\n", err)
+        return
+    }
+    fmt.Printf("文件已复制到: %s\n", copyFile)
+    
+    // 递归列出所有文件
+    allFiles, err := listAllFiles(".")
+    if err != nil {
+        fmt.Printf("递归列出文件错误: %v\n", err)
+        return
+    }
+    fmt.Printf("当前目录及子目录中的所有文件数量: %d\n", len(allFiles))
+    
+    // 清理测试文件
+    os.RemoveAll(testDir)
+    fmt.Println("测试完成，已清理测试文件")
+}
 ```
 
 ### 3.2 网络编程
 ```go
+package main
+
+import (
+    "bufio"
+    "encoding/json"
+    "fmt"
+    "io"
+    "log"
+    "net"
+    "net/http"
+    "os"
+    "strings"
+    "time"
+)
+
 // HTTP客户端
 func httpGet(url string) (string, error) {
     resp, err := http.Get(url)
@@ -55,21 +236,163 @@ func httpGet(url string) (string, error) {
     return string(body), nil
 }
 
+// 带超时的HTTP客户端
+func httpGetWithTimeout(url string, timeout time.Duration) (string, error) {
+    client := http.Client{
+        Timeout: timeout,
+    }
+    
+    resp, err := client.Get(url)
+    if err != nil {
+        return "", err
+    }
+    defer resp.Body.Close()
+    
+    body, err := io.ReadAll(resp.Body)
+    if err != nil {
+        return "", err
+    }
+    return string(body), nil
+}
+
+// POST请求
+func httpPost(url string, data interface{}) (string, error) {
+    jsonData, err := json.Marshal(data)
+    if err != nil {
+        return "", err
+    }
+    
+    resp, err := http.Post(url, "application/json", strings.NewReader(string(jsonData)))
+    if err != nil {
+        return "", err
+    }
+    defer resp.Body.Close()
+    
+    body, err := io.ReadAll(resp.Body)
+    if err != nil {
+        return "", err
+    }
+    return string(body), nil
+}
+
 // HTTP服务器
 func startHTTPServer() {
+    // 静态文件服务
+    fs := http.FileServer(http.Dir("./static"))
+    http.Handle("/static/", http.StripPrefix("/static/", fs))
+    
+    // API路由
     http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
-        fmt.Fprintf(w, "Hello, World!")
+        fmt.Fprintf(w, "Hello, World! 当前时间: %s", time.Now().Format("2006-01-02 15:04:05"))
+    })
+    
+    http.HandleFunc("/api/hello", func(w http.ResponseWriter, r *http.Request) {
+        name := r.URL.Query().Get("name")
+        if name == "" {
+            name = "Guest"
+        }
+        
+        response := map[string]string{
+            "message": fmt.Sprintf("Hello, %s!", name),
+            "time":    time.Now().Format(time.RFC3339),
+        }
+        
+        w.Header().Set("Content-Type", "application/json")
+        json.NewEncoder(w).Encode(response)
+    })
+    
+    http.HandleFunc("/api/data", func(w http.ResponseWriter, r *http.Request) {
+        if r.Method != http.MethodPost {
+            http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
+            return
+        }
+        
+        var data map[string]interface{}
+        if err := json.NewDecoder(r.Body).Decode(&data); err != nil {
+            http.Error(w, "Invalid JSON", http.StatusBadRequest)
+            return
+        }
+        
+        // 处理数据
+        data["processed"] = true
+        data["timestamp"] = time.Now().Unix()
+        
+        w.Header().Set("Content-Type", "application/json")
+        json.NewEncoder(w).Encode(data)
     })
     
-    http.ListenAndServe(":8080", nil)
+    fmt.Println("HTTP服务器启动，监听端口: 8080")
+    log.Fatal(http.ListenAndServe(":8080", nil))
+}
+
+// TCP连接处理
+func handleConnection(conn net.Conn) {
+    defer conn.Close()
+    
+    // 设置连接超时
+    conn.SetDeadline(time.Now().Add(30 * time.Second))
+    
+    // 发送欢迎消息
+    conn.Write([]byte("欢迎连接TCP服务器!\n"))
+    
+    scanner := bufio.NewScanner(conn)
+    for scanner.Scan() {
+        text := scanner.Text()
+        if text == "quit" {
+            break
+        }
+        
+        // 处理命令
+        response := processCommand(text)
+        conn.Write([]byte(response + "\n"))
+    }
+    
+    if err := scanner.Err(); err != nil {
+        fmt.Printf("连接错误: %v\n", err)
+    }
+    
+    fmt.Printf("客户端 %s 断开连接\n", conn.RemoteAddr())
+}
+
+// 处理TCP命令
+func processCommand(command string) string {
+    parts := strings.Fields(command)
+    if len(parts) == 0 {
+        return "无效命令"
+    }
+    
+    switch parts[0] {
+    case "time":
+        return fmt.Sprintf("当前时间: %s", time.Now().Format("2006-01-02 15:04:05"))
+    case "echo":
+        if len(parts) > 1 {
+            return strings.Join(parts[1:], " ")
+        }
+        return "echo需要参数"
+    case "reverse":
+        if len(parts) > 1 {
+            text := strings.Join(parts[1:], " ")
+            runes := []rune(text)
+            for i, j := 0, len(runes)-1; i < j; i, j = i+1, j-1 {
+                runes[i], runes[j] = runes[j], runes[i]
+            }
+            return string(runes)
+        }
+        return "reverse需要参数"
+    default:
+        return fmt.Sprintf("未知命令: %s", parts[0])
+    }
 }
 
 // TCP服务器
 func startTCPServer() {
-    ln, err := net.Listen("tcp", ":8080")
+    ln, err := net.Listen("tcp", ":8081")
     if err != nil {
         log.Fatal(err)
     }
+    defer ln.Close()
+    
+    fmt.Println("TCP服务器启动，监听端口: 8081")
     
     for {
         conn, err := ln.Accept()
@@ -77,145 +400,2404 @@ func startTCPServer() {
             log.Println(err)
             continue
         }
+        
+        fmt.Printf("新客户端连接: %s\n", conn.RemoteAddr())
         go handleConnection(conn)
     }
 }
-```
 
-### 3.3 数据库操作
-```go
-// MySQL连接
-func connectDB() (*sql.DB, error) {
-    db, err := sql.Open("mysql", "user:password@tcp(localhost:3306)/dbname")
+// TCP客户端
+func startTCPClient(serverAddr string) {
+    conn, err := net.Dial("tcp", serverAddr)
     if err != nil {
-        return nil, err
+        log.Fatal(err)
     }
+    defer conn.Close()
     
-    if err := db.Ping(); err != nil {
-        return nil, err
+    fmt.Printf("已连接到TCP服务器: %s\n", serverAddr)
+    
+    // 读取欢迎消息
+    scanner := bufio.NewScanner(conn)
+    if scanner.Scan() {
+        fmt.Println("服务器:", scanner.Text())
     }
     
-    return db, nil
+    // 发送命令
+    reader := bufio.NewReader(os.Stdin)
+    for {
+        fmt.Print("输入命令 (quit退出): ")
+        text, _ := reader.ReadString('\n')
+        text = strings.TrimSpace(text)
+        
+        if text == "quit" {
+            break
+        }
+        
+        // 发送命令
+        fmt.Fprintln(conn, text)
+        
+        // 读取响应
+        if scanner.Scan() {
+            fmt.Println("服务器:", scanner.Text())
+        }
+    }
 }
 
-// CRUD操作
-type User struct {
-    ID   int
-    Name string
-    Age  int
+func main() {
+    if len(os.Args) < 2 {
+        fmt.Println("使用方法:")
+        fmt.Println("  HTTP服务器: go run network.go http")
+        fmt.Println("  TCP服务器: go run network.go tcp-server")
+        fmt.Println("  TCP客户端: go run network.go tcp-client <server:port>")
+        return
+    }
+    
+    mode := os.Args[1]
+    
+    switch mode {
+    case "http":
+        startHTTPServer()
+    case "tcp-server":
+        startTCPServer()
+    case "tcp-client":
+        if len(os.Args) < 3 {
+            fmt.Println("请指定服务器地址")
+            return
+        }
+        serverAddr := os.Args[2]
+        startTCPClient(serverAddr)
+    default:
+        fmt.Println("无效模式")
+    }
 }
+```
 
-func createUser(db *sql.DB, user User) error {
-    _, err := db.Exec("INSERT INTO users (name, age) VALUES (?, ?)", user.Name, user.Age)
-    return err
-}
+### 3.3 数据库操作
+```go
+package main
 
-func getUserByID(db *sql.DB, id int) (User, error) {
-    var user User
-    err := db.QueryRow("SELECT id, name, age FROM users WHERE id = ?", id).Scan(&user.ID, &user.Name, &user.Age)
-    return user, err
+import (
+    "database/sql"
+    "fmt"
+    "log"
+    "time"
+    
+    _ "github.com/go-sql-driver/mysql"
+    _ "github.com/lib/pq"
+    _ "github.com/mattn/go-sqlite3"
+)
+
+// 用户模型
+type User struct {
+    ID        int       `json:"id"`
+    Name      string    `json:"name"`
+    Email     string    `json:"email"`
+    Age       int       `json:"age"`
+    CreatedAt time.Time `json:"created_at"`
+    UpdatedAt time.Time `json:"updated_at"`
 }
-```
 
-### 3.4 JSON/XML数据处理
-```go
-// JSON序列化与反序列化
-type Config struct {
-    Host string `json:"host"`
-    Port int    `json:"port"`
+// 数据库配置
+type DBConfig struct {
+    Driver   string
+    Host     string
+    Port     int
+    Username string
+    Password string
+    Database string
 }
 
-func saveConfig(config Config) error {
-    data, err := json.Marshal(config)
+// MySQL连接
+func connectMySQL(config DBConfig) (*sql.DB, error) {
+    dsn := fmt.Sprintf("%s:%s@tcp(%s:%d)/%s?parseTime=true",
+        config.Username, config.Password, config.Host, config.Port, config.Database)
+    
+    db, err := sql.Open("mysql", dsn)
     if err != nil {
-        return err
+        return nil, err
+    }
+    
+    // 测试连接
+    if err := db.Ping(); err != nil {
+        return nil, err
     }
-    return os.WriteFile("config.json", data, 0644)
+    
+    // 设置连接池
+    db.SetMaxOpenConns(25)
+    db.SetMaxIdleConns(5)
+    db.SetConnMaxLifetime(5 * time.Minute)
+    
+    return db, nil
 }
 
-func loadConfig() (Config, error) {
-    data, err := os.ReadFile("config.json")
+// PostgreSQL连接
+func connectPostgreSQL(config DBConfig) (*sql.DB, error) {
+    dsn := fmt.Sprintf("host=%s port=%d user=%s password=%s dbname=%s sslmode=disable",
+        config.Host, config.Port, config.Username, config.Password, config.Database)
+    
+    db, err := sql.Open("postgres", dsn)
     if err != nil {
-        return Config{}, err
+        return nil, err
     }
     
-    var config Config
-    err = json.Unmarshal(data, &config)
-    return config, err
+    // 测试连接
+    if err := db.Ping(); err != nil {
+        return nil, err
+    }
+    
+    // 设置连接池
+    db.SetMaxOpenConns(25)
+    db.SetMaxIdleConns(5)
+    db.SetConnMaxLifetime(5 * time.Minute)
+    
+    return db, nil
 }
-```
 
-### 3.5 测试与调试
-```go
-// 单元测试
-func TestAdd(t *testing.T) {
-    result := add(2, 3)
-    if result != 5 {
-        t.Errorf("Expected 5, got %d", result)
+// SQLite连接
+func connectSQLite(dbPath string) (*sql.DB, error) {
+    db, err := sql.Open("sqlite3", dbPath)
+    if err != nil {
+        return nil, err
+    }
+    
+    // 测试连接
+    if err := db.Ping(); err != nil {
+        return nil, err
     }
+    
+    return db, nil
 }
 
-// 基准测试
-func BenchmarkAdd(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        add(1, 2)
+// 创建用户表
+func createUserTable(db *sql.DB, driver string) error {
+    var query string
+    
+    switch driver {
+    case "mysql":
+        query = `
+        CREATE TABLE IF NOT EXISTS users (
+            id INT AUTO_INCREMENT PRIMARY KEY,
+            name VARCHAR(100) NOT NULL,
+            email VARCHAR(100) UNIQUE NOT NULL,
+            age INT,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
+        )`
+    case "postgres":
+        query = `
+        CREATE TABLE IF NOT EXISTS users (
+            id SERIAL PRIMARY KEY,
+            name VARCHAR(100) NOT NULL,
+            email VARCHAR(100) UNIQUE NOT NULL,
+            age INT,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        )`
+    case "sqlite3":
+        query = `
+        CREATE TABLE IF NOT EXISTS users (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            name TEXT NOT NULL,
+            email TEXT UNIQUE NOT NULL,
+            age INTEGER,
+            created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+            updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+        )`
+    default:
+        return fmt.Errorf("不支持的数据库驱动: %s", driver)
     }
+    
+    _, err := db.Exec(query)
+    return err
 }
 
-// 性能分析
-func profileCPU() {
-    f, err := os.Create("cpu.prof")
+// 创建用户
+func createUser(db *sql.DB, user User) (int, error) {
+    query := "INSERT INTO users (name, email, age) VALUES (?, ?, ?)"
+    
+    result, err := db.Exec(query, user.Name, user.Email, user.Age)
     if err != nil {
-        log.Fatal(err)
+        return 0, err
     }
-    defer f.Close()
     
-    pprof.StartCPUProfile(f)
-    defer pprof.StopCPUProfile()
+    id, err := result.LastInsertId()
+    if err != nil {
+        return 0, err
+    }
     
-    // 执行需要分析的代码
+    return int(id), nil
 }
-```
-
-## 练习项目
 
-### 项目1：文件备份工具
-```go
-// 实现增量备份功能
-type BackupManager struct {
-    sourceDir string
-    backupDir string
+// 根据ID获取用户
+func getUserByID(db *sql.DB, id int) (User, error) {
+    var user User
+    query := "SELECT id, name, email, age, created_at, updated_at FROM users WHERE id = ?"
+    
+    err := db.QueryRow(query, id).Scan(
+        &user.ID, &user.Name, &user.Email, &user.Age, &user.CreatedAt, &user.UpdatedAt)
+    
+    return user, err
 }
 
-func (bm *BackupManager) Backup() error
-func (bm *BackupManager) Restore(backupName string) error
-func (bm *BackupManager) ListBackups() ([]string, error)
-```
-
-### 项目2：Web爬虫
-```go
-// 并发爬取网页内容
-type Crawler struct {
-    visited map[string]bool
-    mutex   sync.Mutex
+// 获取所有用户
+func getAllUsers(db *sql.DB) ([]User, error) {
+    query := "SELECT id, name, email, age, created_at, updated_at FROM users ORDER BY id"
+    
+    rows, err := db.Query(query)
+    if err != nil {
+        return nil, err
+    }
+    defer rows.Close()
+    
+    var users []User
+    for rows.Next() {
+        var user User
+        err := rows.Scan(
+            &user.ID, &user.Name, &user.Email, &user.Age, &user.CreatedAt, &user.UpdatedAt)
+        if err != nil {
+            return nil, err
+        }
+        users = append(users, user)
+    }
+    
+    if err = rows.Err(); err != nil {
+        return nil, err
+    }
+    
+    return users, nil
 }
 
-func (c *Crawler) Crawl(url string, depth int) ([]string, error)
-func (c *Crawler) extractLinks(html string) []string
-```
-
-### 项目3：数据库CRUD应用
-```go
-// 完整的用户管理系统
-type UserService struct {
-    db *sql.DB
+// 更新用户
+func updateUser(db *sql.DB, user User) error {
+    query := "UPDATE users SET name = ?, email = ?, age = ?, updated_at = ? WHERE id = ?"
+    
+    _, err := db.Exec(query, user.Name, user.Email, user.Age, time.Now(), user.ID)
+    return err
 }
 
-func (us *UserService) CreateUser(user User) error
-func (us *UserService) GetUser(id int) (User, error)
-func (us *UserService) UpdateUser(user User) error
-func (us *UserService) DeleteUser(id int) error
-func (us *UserService) ListUsers() ([]User, error)
+// 删除用户
+func deleteUser(db *sql.DB, id int) error {
+    query := "DELETE FROM users WHERE id = ?"
+    
+    _, err := db.Exec(query, id)
+    return err
+}
+
+// 事务示例
+func transferUsers(db *sql.DB, fromID, toID int) error {
+    tx, err := db.Begin()
+    if err != nil {
+        return err
+    }
+    
+    defer func() {
+        if p := recover(); p != nil {
+            tx.Rollback()
+            panic(p) // 重新抛出panic
+        } else if err != nil {
+            tx.Rollback()
+        } else {
+            err = tx.Commit()
+        }
+    }()
+    
+    // 获取源用户
+    fromUser, err := getUserByID(db, fromID)
+    if err != nil {
+        return err
+    }
+    
+    // 获取目标用户
+    toUser, err := getUserByID(db, toID)
+    if err != nil {
+        return err
+    }
+    
+    // 交换年龄
+    fromUser.Age, toUser.Age = toUser.Age, fromUser.Age
+    
+    // 更新用户
+    if err := updateUser(db, fromUser); err != nil {
+        return err
+    }
+    
+    if err := updateUser(db, toUser); err != nil {
+        return err
+    }
+    
+    return nil
+}
+
+func main() {
+    // 使用SQLite作为示例（无需额外安装）
+    db, err := connectSQLite("./test.db")
+    if err != nil {
+        log.Fatal(err)
+    }
+    defer db.Close()
+    
+    // 创建表
+    if err := createUserTable(db, "sqlite3"); err != nil {
+        log.Fatal(err)
+    }
+    
+    // 创建用户
+    users := []User{
+        {Name: "张三", Email: "[email protected]", Age: 25},
+        {Name: "李四", Email: "[email protected]", Age: 30},
+        {Name: "王五", Email: "[email protected]", Age: 28},
+    }
+    
+    for _, user := range users {
+        id, err := createUser(db, user)
+        if err != nil {
+            log.Printf("创建用户失败: %v", err)
+            continue
+        }
+        fmt.Printf("创建用户成功，ID: %d\n", id)
+    }
+    
+    // 获取所有用户
+    allUsers, err := getAllUsers(db)
+    if err != nil {
+        log.Fatal(err)
+    }
+    
+    fmt.Println("\n所有用户:")
+    for _, user := range allUsers {
+        fmt.Printf("ID: %d, 姓名: %s, 邮箱: %s, 年龄: %d\n",
+            user.ID, user.Name, user.Email, user.Age)
+    }
+    
+    // 更新用户
+    if len(allUsers) > 0 {
+        user := allUsers[0]
+        user.Age = 35
+        if err := updateUser(db, user); err != nil {
+            log.Printf("更新用户失败: %v", err)
+        } else {
+            fmt.Printf("\n用户 %s 年龄已更新为 %d\n", user.Name, user.Age)
+        }
+    }
+    
+    // 事务示例
+    if len(allUsers) >= 2 {
+        fromID := allUsers[0].ID
+        toID := allUsers[1].ID
+        
+        fmt.Printf("\n交换用户 %d 和 %d 的年龄\n", fromID, toID)
+        if err := transferUsers(db, fromID, toID); err != nil {
+            log.Printf("事务失败: %v", err)
+        } else {
+            fmt.Println("事务成功")
+        }
+    }
+    
+    // 再次获取所有用户
+    allUsers, err = getAllUsers(db)
+    if err != nil {
+        log.Fatal(err)
+    }
+    
+    fmt.Println("\n更新后的用户:")
+    for _, user := range allUsers {
+        fmt.Printf("ID: %d, 姓名: %s, 邮箱: %s, 年龄: %d\n",
+            user.ID, user.Name, user.Email, user.Age)
+    }
+    
+    // 删除用户
+    if len(allUsers) > 0 {
+        user := allUsers[0]
+        if err := deleteUser(db, user.ID); err != nil {
+            log.Printf("删除用户失败: %v", err)
+        } else {
+            fmt.Printf("\n用户 %s 已删除\n", user.Name)
+        }
+    }
+}
+```
+
+### 3.4 JSON/XML数据处理
+```go
+package main
+
+import (
+    "encoding/json"
+    "encoding/xml"
+    "fmt"
+    "io"
+    "os"
+    "reflect"
+    "time"
+)
+
+// JSON序列化与反序列化
+type Config struct {
+    Host     string `json:"host"`
+    Port     int    `json:"port"`
+    Debug    bool   `json:"debug"`
+    Database struct {
+        Name     string `json:"name"`
+        User     string `json:"user"`
+        Password string `json:"password"`
+    } `json:"database"`
+}
+
+// 用户结构体
+type User struct {
+    ID        int       `json:"id" xml:"id"`
+    Name      string    `json:"name" xml:"name"`
+    Email     string    `json:"email" xml:"email"`
+    Age       int       `json:"age" xml:"age"`
+    CreatedAt time.Time `json:"created_at" xml:"created_at"`
+}
+
+// 用户列表结构体（用于XML）
+type UserList struct {
+    XMLName xml.Name `xml:"users"`
+    Users   []User   `xml:"user"`
+}
+
+// 保存配置为JSON
+func saveConfig(config Config, filename string) error {
+    data, err := json.MarshalIndent(config, "", "  ")
+    if err != nil {
+        return err
+    }
+    return os.WriteFile(filename, data, 0644)
+}
+
+// 从JSON加载配置
+func loadConfig(filename string) (Config, error) {
+    data, err := os.ReadFile(filename)
+    if err != nil {
+        return Config{}, err
+    }
+    
+    var config Config
+    err = json.Unmarshal(data, &config)
+    return config, err
+}
+
+// 保存用户为JSON
+func saveUsersToJSON(users []User, filename string) error {
+    data, err := json.MarshalIndent(users, "", "  ")
+    if err != nil {
+        return err
+    }
+    return os.WriteFile(filename, data, 0644)
+}
+
+// 从JSON加载用户
+func loadUsersFromJSON(filename string) ([]User, error) {
+    data, err := os.ReadFile(filename)
+    if err != nil {
+        return nil, err
+    }
+    
+    var users []User
+    err = json.Unmarshal(data, &users)
+    return users, err
+}
+
+// 保存用户为XML
+func saveUsersToXML(users []User, filename string) error {
+    userList := UserList{Users: users}
+    data, err := xml.MarshalIndent(userList, "", "  ")
+    if err != nil {
+        return err
+    }
+    return os.WriteFile(filename, data, 0644)
+}
+
+// 从XML加载用户
+func loadUsersFromXML(filename string) ([]User, error) {
+    data, err := os.ReadFile(filename)
+    if err != nil {
+        return nil, err
+    }
+    
+    var userList UserList
+    err = xml.Unmarshal(data, &userList)
+    return userList.Users, err
+}
+
+// 流式JSON处理
+func streamJSONFile(filename string) error {
+    file, err := os.Open(filename)
+    if err != nil {
+        return err
+    }
+    defer file.Close()
+    
+    decoder := json.NewDecoder(file)
+    
+    // 读取开头的 [
+    token, err := decoder.Token()
+    if err != nil {
+        return err
+    }
+    
+    if token != json.Delim('[') {
+        return fmt.Errorf("期望JSON数组开始，得到: %v", token)
+    }
+    
+    // 读取数组中的每个对象
+    for decoder.More() {
+        var user User
+        err := decoder.Decode(&user)
+        if err != nil {
+            return err
+        }
+        
+        fmt.Printf("用户: %+v\n", user)
+    }
+    
+    // 读取结尾的 ]
+    token, err = decoder.Token()
+    if err != nil {
+        return err
+    }
+    
+    if token != json.Delim(']') {
+        return fmt.Errorf("期望JSON数组结束，得到: %v", token)
+    }
+    
+    return nil
+}
+
+// 流式XML处理
+func streamXMLFile(filename string) error {
+    file, err := os.Open(filename)
+    if err != nil {
+        return err
+    }
+    defer file.Close()
+    
+    decoder := xml.NewDecoder(file)
+    
+    for {
+        token, err := decoder.Token()
+        if err == io.EOF {
+            break
+        }
+        if err != nil {
+            return err
+        }
+        
+        switch se := token.(type) {
+        case xml.StartElement:
+            if se.Name.Local == "user" {
+                var user User
+                err := decoder.DecodeElement(&user, &se)
+                if err != nil {
+                    return err
+                }
+                fmt.Printf("用户: %+v\n", user)
+            }
+        }
+    }
+    
+    return nil
+}
+
+// 反射获取结构体标签
+func printStructTags(obj interface{}) {
+    v := reflect.ValueOf(obj)
+    t := reflect.TypeOf(obj)
+    
+    if t.Kind() == reflect.Ptr {
+        t = t.Elem()
+        v = v.Elem()
+    }
+    
+    if t.Kind() != reflect.Struct {
+        fmt.Println("不是结构体")
+        return
+    }
+    
+    for i := 0; i < t.NumField(); i++ {
+        field := t.Field(i)
+        jsonTag := field.Tag.Get("json")
+        xmlTag := field.Tag.Get("xml")
+        
+        fmt.Printf("字段: %s, 类型: %v, JSON标签: %s, XML标签: %s\n",
+            field.Name, field.Type, jsonTag, xmlTag)
+    }
+}
+
+func main() {
+    // 创建示例配置
+    config := Config{
+        Host:  "localhost",
+        Port:  8080,
+        Debug: true,
+    }
+    config.Database.Name = "mydb"
+    config.Database.User = "admin"
+    config.Database.Password = "password"
+    
+    // 保存配置
+    err := saveConfig(config, "config.json")
+    if err != nil {
+        fmt.Printf("保存配置失败: %v\n", err)
+        return
+    }
+    
+    // 加载配置
+    loadedConfig, err := loadConfig("config.json")
+    if err != nil {
+        fmt.Printf("加载配置失败: %v\n", err)
+        return
+    }
+    
+    fmt.Printf("加载的配置: %+v\n", loadedConfig)
+    
+    // 创建示例用户
+    users := []User{
+        {ID: 1, Name: "张三", Email: "[email protected]", Age: 25, CreatedAt: time.Now()},
+        {ID: 2, Name: "李四", Email: "[email protected]", Age: 30, CreatedAt: time.Now()},
+        {ID: 3, Name: "王五", Email: "[email protected]", Age: 28, CreatedAt: time.Now()},
+    }
+    
+    // 保存用户为JSON
+    err = saveUsersToJSON(users, "users.json")
+    if err != nil {
+        fmt.Printf("保存用户JSON失败: %v\n", err)
+        return
+    }
+    
+    // 保存用户为XML
+    err = saveUsersToXML(users, "users.xml")
+    if err != nil {
+        fmt.Printf("保存用户XML失败: %v\n", err)
+        return
+    }
+    
+    // 从JSON加载用户
+    loadedUsers, err := loadUsersFromJSON("users.json")
+    if err != nil {
+        fmt.Printf("加载用户JSON失败: %v\n", err)
+        return
+    }
+    
+    fmt.Println("\n从JSON加载的用户:")
+    for _, user := range loadedUsers {
+        fmt.Printf("ID: %d, 姓名: %s, 邮箱: %s, 年龄: %d\n",
+            user.ID, user.Name, user.Email, user.Age)
+    }
+    
+    // 从XML加载用户
+    loadedUsersFromXML, err := loadUsersFromXML("users.xml")
+    if err != nil {
+        fmt.Printf("加载用户XML失败: %v\n", err)
+        return
+    }
+    
+    fmt.Println("\n从XML加载的用户:")
+    for _, user := range loadedUsersFromXML {
+        fmt.Printf("ID: %d, 姓名: %s, 邮箱: %s, 年龄: %d\n",
+            user.ID, user.Name, user.Email, user.Age)
+    }
+    
+    // 流式处理JSON
+    fmt.Println("\n流式处理JSON:")
+    err = streamJSONFile("users.json")
+    if err != nil {
+        fmt.Printf("流式处理JSON失败: %v\n", err)
+    }
+    
+    // 流式处理XML
+    fmt.Println("\n流式处理XML:")
+    err = streamXMLFile("users.xml")
+    if err != nil {
+        fmt.Printf("流式处理XML失败: %v\n", err)
+    }
+    
+    // 打印结构体标签
+    fmt.Println("\nUser结构体标签:")
+    printStructTags(User{})
+    
+    // 清理文件
+    os.Remove("config.json")
+    os.Remove("users.json")
+    os.Remove("users.xml")
+}
+```
+
+### 3.5 测试与调试
+```go
+package main
+
+import (
+    "fmt"
+    "math"
+    "os"
+    "runtime"
+    "runtime/pprof"
+    "sort"
+    "testing"
+    "time"
+)
+
+// 被测试的函数
+func add(a, b int) int {
+    return a + b
+}
+
+func multiply(a, b int) int {
+    return a * b
+}
+
+func divide(a, b float64) (float64, error) {
+    if b == 0 {
+        return 0, fmt.Errorf("division by zero")
+    }
+    return a / b, nil
+}
+
+// 计算斐波那契数列
+func fibonacci(n int) int {
+    if n <= 1 {
+        return n
+    }
+    return fibonacci(n-1) + fibonacci(n-2)
+}
+
+// 优化的斐波那契数列
+func fibonacciOptimized(n int) int {
+    if n <= 1 {
+        return n
+    }
+    
+    a, b := 0, 1
+    for i := 2; i <= n; i++ {
+        a, b = b, a+b
+    }
+    return b
+}
+
+// 排序函数
+func bubbleSort(arr []int) []int {
+    n := len(arr)
+    result := make([]int, n)
+    copy(result, arr)
+    
+    for i := 0; i < n-1; i++ {
+        for j := 0; j < n-i-1; j++ {
+            if result[j] > result[j+1] {
+                result[j], result[j+1] = result[j+1], result[j]
+            }
+        }
+    }
+    
+    return result
+}
+
+// 单元测试
+func TestAdd(t *testing.T) {
+    tests := []struct {
+        a, b     int
+        expected int
+    }{
+        {1, 2, 3},
+        {-1, 1, 0},
+        {0, 0, 0},
+        {100, 200, 300},
+    }
+    
+    for _, test := range tests {
+        result := add(test.a, test.b)
+        if result != test.expected {
+            t.Errorf("add(%d, %d) = %d; expected %d", test.a, test.b, result, test.expected)
+        }
+    }
+}
+
+func TestMultiply(t *testing.T) {
+    tests := []struct {
+        a, b     int
+        expected int
+    }{
+        {2, 3, 6},
+        {-2, 3, -6},
+        {0, 5, 0},
+        {10, 10, 100},
+    }
+    
+    for _, test := range tests {
+        result := multiply(test.a, test.b)
+        if result != test.expected {
+            t.Errorf("multiply(%d, %d) = %d; expected %d", test.a, test.b, result, test.expected)
+        }
+    }
+}
+
+func TestDivide(t *testing.T) {
+    // 测试正常情况
+    result, err := divide(10, 2)
+    if err != nil {
+        t.Errorf("divide(10, 2) returned error: %v", err)
+    }
+    if math.Abs(result-5.0) > 1e-9 {
+        t.Errorf("divide(10, 2) = %f; expected 5.0", result)
+    }
+    
+    // 测试除零错误
+    _, err = divide(10, 0)
+    if err == nil {
+        t.Error("divide(10, 0) should return an error")
+    }
+}
+
+func TestFibonacci(t *testing.T) {
+    tests := []struct {
+        n, expected int
+    }{
+        {0, 0},
+        {1, 1},
+        {2, 1},
+        {3, 2},
+        {4, 3},
+        {5, 5},
+        {10, 55},
+    }
+    
+    for _, test := range tests {
+        result := fibonacci(test.n)
+        if result != test.expected {
+            t.Errorf("fibonacci(%d) = %d; expected %d", test.n, result, test.expected)
+        }
+    }
+}
+
+func TestFibonacciOptimized(t *testing.T) {
+    tests := []struct {
+        n, expected int
+    }{
+        {0, 0},
+        {1, 1},
+        {2, 1},
+        {3, 2},
+        {4, 3},
+        {5, 5},
+        {10, 55},
+        {20, 6765},
+    }
+    
+    for _, test := range tests {
+        result := fibonacciOptimized(test.n)
+        if result != test.expected {
+            t.Errorf("fibonacciOptimized(%d) = %d; expected %d", test.n, result, test.expected)
+        }
+    }
+}
+
+func TestBubbleSort(t *testing.T) {
+    tests := []struct {
+        input    []int
+        expected []int
+    }{
+        {[]int{5, 3, 8, 4, 2}, []int{2, 3, 4, 5, 8}},
+        {[]int{1, 2, 3, 4, 5}, []int{1, 2, 3, 4, 5}},
+        {[]int{5, 4, 3, 2, 1}, []int{1, 2, 3, 4, 5}},
+        {[]int{}, []int{}},
+        {[]int{42}, []int{42}},
+    }
+    
+    for _, test := range tests {
+        result := bubbleSort(test.input)
+        if !equal(result, test.expected) {
+            t.Errorf("bubbleSort(%v) = %v; expected %v", test.input, result, test.expected)
+        }
+    }
+}
+
+// 辅助函数：比较两个整数切片是否相等
+func equal(a, b []int) bool {
+    if len(a) != len(b) {
+        return false
+    }
+    for i := range a {
+        if a[i] != b[i] {
+            return false
+        }
+    }
+    return true
+}
+
+// 基准测试
+func BenchmarkAdd(b *testing.B) {
+    for i := 0; i < b.N; i++ {
+        add(1, 2)
+    }
+}
+
+func BenchmarkMultiply(b *testing.B) {
+    for i := 0; i < b.N; i++ {
+        multiply(123, 456)
+    }
+}
+
+func BenchmarkFibonacci(b *testing.B) {
+    for i := 0; i < b.N; i++ {
+        fibonacci(10)
+    }
+}
+
+func BenchmarkFibonacciOptimized(b *testing.B) {
+    for i := 0; i < b.N; i++ {
+        fibonacciOptimized(10)
+    }
+}
+
+func BenchmarkBubbleSort(b *testing.B) {
+    // 创建测试数据
+    data := make([]int, 100)
+    for i := range data {
+        data[i] = 100 - i // 逆序数组
+    }
+    
+    b.ResetTimer()
+    for i := 0; i < b.N; i++ {
+        bubbleSort(data)
+    }
+}
+
+func BenchmarkSort(b *testing.B) {
+    // 创建测试数据
+    data := make([]int, 100)
+    for i := range data {
+        data[i] = 100 - i // 逆序数组
+    }
+    
+    b.ResetTimer()
+    for i := 0; i < b.N; i++ {
+        // 复制数据以避免修改原始数据
+        testData := make([]int, len(data))
+        copy(testData, data)
+        sort.Ints(testData)
+    }
+}
+
+// 性能分析
+func profileCPU(filename string, fn func()) error {
+    f, err := os.Create(filename)
+    if err != nil {
+        return err
+    }
+    defer f.Close()
+    
+    if err := pprof.StartCPUProfile(f); err != nil {
+        return err
+    }
+    defer pprof.StopCPUProfile()
+    
+    fn()
+    return nil
+}
+
+// 内存分析
+func profileMemory(filename string, fn func()) error {
+    f, err := os.Create(filename)
+    if err != nil {
+        return err
+    }
+    defer f.Close()
+    
+    runtime.GC() // 获取最新的GC数据
+    
+    if err := pprof.WriteHeapProfile(f); err != nil {
+        return err
+    }
+    
+    fn()
+    return nil
+}
+
+// 示例函数
+func ExampleAdd() {
+    result := add(2, 3)
+    fmt.Println(result)
+    // Output: 5
+}
+
+func ExampleFibonacci() {
+    fmt.Println(fibonacci(5))
+    // Output: 5
+}
+
+// 测试主函数
+func main() {
+    // 性能分析示例
+    fmt.Println("开始性能分析...")
+    
+    // CPU性能分析
+    err := profileCPU("cpu.prof", func() {
+        // 执行一些计算密集型任务
+        for i := 0; i < 1000; i++ {
+            fibonacciOptimized(20)
+        }
+    })
+    
+    if err != nil {
+        fmt.Printf("CPU性能分析失败: %v\n", err)
+    } else {
+        fmt.Println("CPU性能分析完成，结果保存到 cpu.prof")
+    }
+    
+    // 内存性能分析
+    err = profileMemory("mem.prof", func() {
+        // 创建一些数据
+        data := make([][]int, 100)
+        for i := range data {
+            data[i] = make([]int, 1000)
+            for j := range data[i] {
+                data[i][j] = i * j
+            }
+        }
+    })
+    
+    if err != nil {
+        fmt.Printf("内存性能分析失败: %v\n", err)
+    } else {
+        fmt.Println("内存性能分析完成，结果保存到 mem.prof")
+    }
+    
+    // 运行基准测试
+    fmt.Println("\n运行基准测试...")
+    result := testing.Benchmark(BenchmarkFibonacci)
+    fmt.Printf("fibonacci(10) 基准测试结果: %s\n", result)
+    
+    result = testing.Benchmark(BenchmarkFibonacciOptimized)
+    fmt.Printf("fibonacciOptimized(10) 基准测试结果: %s\n", result)
+    
+    // 比较两种斐波那契实现的性能
+    n := 30
+    start := time.Now()
+    result1 := fibonacci(n)
+    duration1 := time.Since(start)
+    
+    start = time.Now()
+    result2 := fibonacciOptimized(n)
+    duration2 := time.Since(start)
+    
+    fmt.Printf("\n斐波那契数列第%d项:\n", n)
+    fmt.Printf("递归实现: %d, 耗时: %v\n", result1, duration1)
+    fmt.Printf("优化实现: %d, 耗时: %v\n", result2, duration2)
+    fmt.Printf("性能提升: %.2fx\n", float64(duration1)/float64(duration2))
+    
+    // 清理分析文件
+    os.Remove("cpu.prof")
+    os.Remove("mem.prof")
+}
+```
+
+## 练习项目
+
+### 项目1：文件备份工具
+```go
+package main
+
+import (
+    "archive/zip"
+    "bufio"
+    "crypto/md5"
+    "fmt"
+    "io"
+    "os"
+    "path/filepath"
+    "sort"
+    "strings"
+    "time"
+)
+
+// 文件信息
+type FileInfo struct {
+    Path     string
+    Size     int64
+    ModTime  time.Time
+    Hash     string
+    IsDir    bool
+}
+
+// 备份信息
+type BackupInfo struct {
+    Name      string
+    Timestamp time.Time
+    Files     []FileInfo
+    Size      int64
+}
+
+// 备份管理器
+type BackupManager struct {
+    sourceDir string
+    backupDir string
+    indexFile string
+}
+
+// 创建新的备份管理器
+func NewBackupManager(sourceDir, backupDir string) *BackupManager {
+    return &BackupManager{
+        sourceDir: sourceDir,
+        backupDir: backupDir,
+        indexFile: filepath.Join(backupDir, "index.json"),
+    }
+}
+
+// 获取文件哈希
+func getFileHash(filePath string) (string, error) {
+    file, err := os.Open(filePath)
+    if err != nil {
+        return "", err
+    }
+    defer file.Close()
+    
+    hash := md5.New()
+    if _, err := io.Copy(hash, file); err != nil {
+        return "", err
+    }
+    
+    return fmt.Sprintf("%x", hash.Sum(nil)), nil
+}
+
+// 扫描目录获取文件信息
+func (bm *BackupManager) scanDirectory() ([]FileInfo, error) {
+    var files []FileInfo
+    
+    err := filepath.Walk(bm.sourceDir, func(path string, info os.FileInfo, err error) error {
+        if err != nil {
+            return err
+        }
+        
+        // 获取相对路径
+        relPath, err := filepath.Rel(bm.sourceDir, path)
+        if err != nil {
+            return err
+        }
+        
+        // 跳过备份目录本身
+        if strings.HasPrefix(relPath, bm.backupDir) {
+            return nil
+        }
+        
+        fileHash := ""
+        if !info.IsDir() {
+            fileHash, err = getFileHash(path)
+            if err != nil {
+                return err
+            }
+        }
+        
+        files = append(files, FileInfo{
+            Path:    relPath,
+            Size:    info.Size(),
+            ModTime: info.ModTime(),
+            Hash:    fileHash,
+            IsDir:   info.IsDir(),
+        })
+        
+        return nil
+    })
+    
+    return files, err
+}
+
+// 创建备份
+func (bm *BackupManager) Backup() error {
+    // 确保备份目录存在
+    if err := os.MkdirAll(bm.backupDir, 0755); err != nil {
+        return fmt.Errorf("创建备份目录失败: %v", err)
+    }
+    
+    // 扫描源目录
+    files, err := bm.scanDirectory()
+    if err != nil {
+        return fmt.Errorf("扫描目录失败: %v", err)
+    }
+    
+    // 创建备份名称
+    timestamp := time.Now().Format("20060102_150405")
+    backupName := fmt.Sprintf("backup_%s.zip", timestamp)
+    backupPath := filepath.Join(bm.backupDir, backupName)
+    
+    // 创建ZIP文件
+    zipFile, err := os.Create(backupPath)
+    if err != nil {
+        return fmt.Errorf("创建备份文件失败: %v", err)
+    }
+    defer zipFile.Close()
+    
+    zipWriter := zip.NewWriter(zipFile)
+    defer zipWriter.Close()
+    
+    var totalSize int64
+    
+    // 添加文件到ZIP
+    for _, file := range files {
+        if file.IsDir {
+            continue
+        }
+        
+        // 打开源文件
+        sourcePath := filepath.Join(bm.sourceDir, file.Path)
+        sourceFile, err := os.Open(sourcePath)
+        if err != nil {
+            return fmt.Errorf("打开源文件失败: %v", err)
+        }
+        
+        // 在ZIP中创建文件
+        header, err := zip.FileInfoHeader(fileInfoFromPath(sourcePath))
+        if err != nil {
+            sourceFile.Close()
+            return fmt.Errorf("创建ZIP头失败: %v", err)
+        }
+        header.Name = file.Path
+        header.Method = zip.Deflate
+        
+        writer, err := zipWriter.CreateHeader(header)
+        if err != nil {
+            sourceFile.Close()
+            return fmt.Errorf("在ZIP中创建文件失败: %v", err)
+        }
+        
+        // 复制文件内容
+        _, err = io.Copy(writer, sourceFile)
+        sourceFile.Close()
+        
+        if err != nil {
+            return fmt.Errorf("复制文件内容失败: %v", err)
+        }
+        
+        totalSize += file.Size
+    }
+    
+    // 保存备份信息
+    backupInfo := BackupInfo{
+        Name:      backupName,
+        Timestamp: time.Now(),
+        Files:     files,
+        Size:      totalSize,
+    }
+    
+    if err := bm.saveBackupInfo(backupInfo); err != nil {
+        return fmt.Errorf("保存备份信息失败: %v", err)
+    }
+    
+    fmt.Printf("备份完成: %s (大小: %.2f MB)\n", backupName, float64(totalSize)/1024/1024)
+    return nil
+}
+
+// 从路径创建文件信息
+func fileInfoFromPath(path string) os.FileInfo {
+    info, _ := os.Stat(path)
+    return info
+}
+
+// 保存备份信息
+func (bm *BackupManager) saveBackupInfo(info BackupInfo) error {
+    // 这里简化处理，实际应用中可以使用JSON或其他格式
+    indexFile, err := os.OpenFile(bm.indexFile, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
+    if err != nil {
+        return err
+    }
+    defer indexFile.Close()
+    
+    writer := bufio.NewWriter(indexFile)
+    defer writer.Flush()
+    
+    line := fmt.Sprintf("%s|%s|%d\n", info.Name, info.Timestamp.Format(time.RFC3339), info.Size)
+    _, err = writer.WriteString(line)
+    return err
+}
+
+// 列出所有备份
+func (bm *BackupManager) ListBackups() ([]BackupInfo, error) {
+    file, err := os.Open(bm.indexFile)
+    if err != nil {
+        if os.IsNotExist(err) {
+            return []BackupInfo{}, nil
+        }
+        return nil, err
+    }
+    defer file.Close()
+    
+    var backups []BackupInfo
+    scanner := bufio.NewScanner(file)
+    
+    for scanner.Scan() {
+        line := scanner.Text()
+        parts := strings.Split(line, "|")
+        if len(parts) != 3 {
+            continue
+        }
+        
+        timestamp, err := time.Parse(time.RFC3339, parts[1])
+        if err != nil {
+            continue
+        }
+        
+        var size int64
+        fmt.Sscanf(parts[2], "%d", &size)
+        
+        backups = append(backups, BackupInfo{
+            Name:      parts[0],
+            Timestamp: timestamp,
+            Size:      size,
+        })
+    }
+    
+    // 按时间戳排序
+    sort.Slice(backups, func(i, j int) bool {
+        return backups[i].Timestamp.After(backups[j].Timestamp)
+    })
+    
+    return backups, nil
+}
+
+// 恢复备份
+func (bm *BackupManager) Restore(backupName string) error {
+    backupPath := filepath.Join(bm.backupDir, backupName)
+    
+    // 打开ZIP文件
+    reader, err := zip.OpenReader(backupPath)
+    if err != nil {
+        return fmt.Errorf("打开备份文件失败: %v", err)
+    }
+    defer reader.Close()
+    
+    // 解压文件
+    for _, file := range reader.File {
+        path := filepath.Join(bm.sourceDir, file.Name)
+        
+        // 创建目录
+        if file.FileInfo().IsDir() {
+            if err := os.MkdirAll(path, file.FileInfo().Mode()); err != nil {
+                return fmt.Errorf("创建目录失败: %v", err)
+            }
+            continue
+        }
+        
+        // 确保父目录存在
+        if err := os.MkdirAll(filepath.Dir(path), 0755); err != nil {
+            return fmt.Errorf("创建父目录失败: %v", err)
+        }
+        
+        // 打开ZIP中的文件
+        fileReader, err := file.Open()
+        if err != nil {
+            return fmt.Errorf("打开ZIP中的文件失败: %v", err)
+        }
+        
+        // 创建目标文件
+        targetFile, err := os.OpenFile(path, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, file.FileInfo().Mode())
+        if err != nil {
+            fileReader.Close()
+            return fmt.Errorf("创建目标文件失败: %v", err)
+        }
+        
+        // 复制文件内容
+        _, err = io.Copy(targetFile, fileReader)
+        fileReader.Close()
+        targetFile.Close()
+        
+        if err != nil {
+            return fmt.Errorf("复制文件内容失败: %v", err)
+        }
+    }
+    
+    fmt.Printf("恢复完成: %s\n", backupName)
+    return nil
+}
+
+// 增量备份
+func (bm *BackupManager) IncrementalBackup() error {
+    // 获取最新的备份信息
+    backups, err := bm.ListBackups()
+    if err != nil {
+        return err
+    }
+    
+    if len(backups) == 0 {
+        // 如果没有备份，执行完整备份
+        return bm.Backup()
+    }
+    
+    // 获取当前文件信息
+    currentFiles, err := bm.scanDirectory()
+    if err != nil {
+        return err
+    }
+    
+    // 这里简化处理，实际应用中需要比较文件哈希和修改时间
+    // 只备份有变化的文件
+    var changedFiles []FileInfo
+    for _, file := range currentFiles {
+        if file.IsDir {
+            continue
+        }
+        
+        // 简化处理：备份最近修改的文件
+        if time.Since(file.ModTime) < 24*time.Hour {
+            changedFiles = append(changedFiles, file)
+        }
+    }
+    
+    if len(changedFiles) == 0 {
+        fmt.Println("没有文件需要备份")
+        return nil
+    }
+    
+    // 创建增量备份
+    timestamp := time.Now().Format("20060102_150405")
+    backupName := fmt.Sprintf("incremental_%s.zip", timestamp)
+    backupPath := filepath.Join(bm.backupDir, backupName)
+    
+    // 创建ZIP文件
+    zipFile, err := os.Create(backupPath)
+    if err != nil {
+        return fmt.Errorf("创建备份文件失败: %v", err)
+    }
+    defer zipFile.Close()
+    
+    zipWriter := zip.NewWriter(zipFile)
+    defer zipWriter.Close()
+    
+    var totalSize int64
+    
+    // 添加变化的文件到ZIP
+    for _, file := range changedFiles {
+        sourcePath := filepath.Join(bm.sourceDir, file.Path)
+        sourceFile, err := os.Open(sourcePath)
+        if err != nil {
+            return fmt.Errorf("打开源文件失败: %v", err)
+        }
+        
+        header, err := zip.FileInfoHeader(fileInfoFromPath(sourcePath))
+        if err != nil {
+            sourceFile.Close()
+            return fmt.Errorf("创建ZIP头失败: %v", err)
+        }
+        header.Name = file.Path
+        header.Method = zip.Deflate
+        
+        writer, err := zipWriter.CreateHeader(header)
+        if err != nil {
+            sourceFile.Close()
+            return fmt.Errorf("在ZIP中创建文件失败: %v", err)
+        }
+        
+        _, err = io.Copy(writer, sourceFile)
+        sourceFile.Close()
+        
+        if err != nil {
+            return fmt.Errorf("复制文件内容失败: %v", err)
+        }
+        
+        totalSize += file.Size
+    }
+    
+    // 保存备份信息
+    backupInfo := BackupInfo{
+        Name:      backupName,
+        Timestamp: time.Now(),
+        Files:     changedFiles,
+        Size:      totalSize,
+    }
+    
+    if err := bm.saveBackupInfo(backupInfo); err != nil {
+        return fmt.Errorf("保存备份信息失败: %v", err)
+    }
+    
+    fmt.Printf("增量备份完成: %s (文件数: %d, 大小: %.2f MB)\n", 
+        backupName, len(changedFiles), float64(totalSize)/1024/1024)
+    return nil
+}
+
+func main() {
+    if len(os.Args) < 3 {
+        fmt.Println("使用方法:")
+        fmt.Println("  完整备份: go run backup.go backup <源目录> <备份目录>")
+        fmt.Println("  增量备份: go run backup.go incremental <源目录> <备份目录>")
+        fmt.Println("  恢复备份: go run backup.go restore <源目录> <备份目录> <备份文件名>")
+        fmt.Println("  列出备份: go run backup.go list <备份目录>")
+        return
+    }
+    
+    command := os.Args[1]
+    
+    switch command {
+    case "backup":
+        if len(os.Args) < 4 {
+            fmt.Println("请指定源目录和备份目录")
+            return
+        }
+        sourceDir := os.Args[2]
+        backupDir := os.Args[3]
+        
+        manager := NewBackupManager(sourceDir, backupDir)
+        if err := manager.Backup(); err != nil {
+            fmt.Printf("备份失败: %v\n", err)
+        }
+        
+    case "incremental":
+        if len(os.Args) < 4 {
+            fmt.Println("请指定源目录和备份目录")
+            return
+        }
+        sourceDir := os.Args[2]
+        backupDir := os.Args[3]
+        
+        manager := NewBackupManager(sourceDir, backupDir)
+        if err := manager.IncrementalBackup(); err != nil {
+            fmt.Printf("增量备份失败: %v\n", err)
+        }
+        
+    case "restore":
+        if len(os.Args) < 5 {
+            fmt.Println("请指定源目录、备份目录和备份文件名")
+            return
+        }
+        sourceDir := os.Args[2]
+        backupDir := os.Args[3]
+        backupName := os.Args[4]
+        
+        manager := NewBackupManager(sourceDir, backupDir)
+        if err := manager.Restore(backupName); err != nil {
+            fmt.Printf("恢复失败: %v\n", err)
+        }
+        
+    case "list":
+        if len(os.Args) < 3 {
+            fmt.Println("请指定备份目录")
+            return
+        }
+        backupDir := os.Args[2]
+        
+        manager := NewBackupManager("", backupDir)
+        backups, err := manager.ListBackups()
+        if err != nil {
+            fmt.Printf("列出备份失败: %v\n", err)
+            return
+        }
+        
+        if len(backups) == 0 {
+            fmt.Println("没有找到备份")
+            return
+        }
+        
+        fmt.Println("可用备份:")
+        for _, backup := range backups {
+            fmt.Printf("%s - %s (%.2f MB)\n", 
+                backup.Name, 
+                backup.Timestamp.Format("2006-01-02 15:04:05"), 
+                float64(backup.Size)/1024/1024)
+        }
+        
+    default:
+        fmt.Println("未知命令")
+    }
+}
+```
+
+### 项目2：Web爬虫
+```go
+package main
+
+import (
+    "fmt"
+    "io"
+    "net/http"
+    "net/url"
+    "os"
+    "regexp"
+    "strings"
+    "sync"
+    "time"
+)
+
+// 网页信息
+type PageInfo struct {
+    URL   string
+    Title string
+    Links []string
+    Error error
+}
+
+// 爬虫结构体
+type Crawler struct {
+    visited    map[string]bool
+    mutex      sync.Mutex
+    maxDepth   int
+    delay      time.Duration
+    userAgent  string
+    resultChan chan PageInfo
+    wg         sync.WaitGroup
+}
+
+// 创建新的爬虫
+func NewCrawler(maxDepth int, delay time.Duration) *Crawler {
+    return &Crawler{
+        visited:    make(map[string]bool),
+        maxDepth:   maxDepth,
+        delay:      delay,
+        userAgent:  "GoCrawler/1.0",
+        resultChan: make(chan PageInfo, 100),
+    }
+}
+
+// 提取网页标题
+func extractTitle(html string) string {
+    // 简单的正则表达式提取标题
+    titleRegex := regexp.MustCompile(`<title>(.*?)</title>`)
+    matches := titleRegex.FindStringSubmatch(html)
+    if len(matches) > 1 {
+        return strings.TrimSpace(matches[1])
+    }
+    return ""
+}
+
+// 提取链接
+func (c *Crawler) extractLinks(baseURL string, html string) []string {
+    // 提取所有href属性
+    linkRegex := regexp.MustCompile(`<a[^>]+href=["']([^"']+)["']`)
+    matches := linkRegex.FindAllStringSubmatch(html, -1)
+    
+    var links []string
+    base, err := url.Parse(baseURL)
+    if err != nil {
+        return links
+    }
+    
+    for _, match := range matches {
+        if len(match) > 1 {
+            href := match[1]
+            
+            // 解析相对URL
+            parsedURL, err := url.Parse(href)
+            if err != nil {
+                continue
+            }
+            
+            absoluteURL := base.ResolveReference(parsedURL).String()
+            
+            // 只保留同域名的链接
+            if parsedURL.Host == "" || parsedURL.Host == base.Host {
+                links = append(links, absoluteURL)
+            }
+        }
+    }
+    
+    return links
+}
+
+// 获取网页内容
+func (c *Crawler) fetchPage(urlStr string) (string, error) {
+    // 检查是否已访问
+    c.mutex.Lock()
+    if c.visited[urlStr] {
+        c.mutex.Unlock()
+        return "", fmt.Errorf("URL已访问: %s", urlStr)
+    }
+    c.visited[urlStr] = true
+    c.mutex.Unlock()
+    
+    // 创建请求
+    req, err := http.NewRequest("GET", urlStr, nil)
+    if err != nil {
+        return "", err
+    }
+    
+    req.Header.Set("User-Agent", c.userAgent)
+    
+    // 发送请求
+    client := &http.Client{Timeout: 10 * time.Second}
+    resp, err := client.Do(req)
+    if err != nil {
+        return "", err
+    }
+    defer resp.Body.Close()
+    
+    // 检查状态码
+    if resp.StatusCode != http.StatusOK {
+        return "", fmt.Errorf("HTTP错误: %d", resp.StatusCode)
+    }
+    
+    // 读取内容
+    body, err := io.ReadAll(resp.Body)
+    if err != nil {
+        return "", err
+    }
+    
+    // 检查内容类型
+    contentType := resp.Header.Get("Content-Type")
+    if !strings.Contains(contentType, "text/html") {
+        return "", fmt.Errorf("非HTML内容: %s", contentType)
+    }
+    
+    return string(body), nil
+}
+
+// 爬取单个页面
+func (c *Crawler) crawlPage(urlStr string, depth int) {
+    defer c.wg.Done()
+    
+    // 检查深度
+    if depth > c.maxDepth {
+        return
+    }
+    
+    // 延迟请求
+    time.Sleep(c.delay)
+    
+    // 获取页面内容
+    html, err := c.fetchPage(urlStr)
+    
+    // 提取信息
+    pageInfo := PageInfo{
+        URL:   urlStr,
+        Error: err,
+    }
+    
+    if err == nil {
+        pageInfo.Title = extractTitle(html)
+        pageInfo.Links = c.extractLinks(urlStr, html)
+        
+        // 爬取链接页面
+        for _, link := range pageInfo.Links {
+            c.wg.Add(1)
+            go c.crawlPage(link, depth+1)
+        }
+    }
+    
+    // 发送结果
+    c.resultChan <- pageInfo
+}
+
+// 开始爬取
+func (c *Crawler) Crawl(startURL string) []PageInfo {
+    // 启动爬取
+    c.wg.Add(1)
+    go c.crawlPage(startURL, 0)
+    
+    // 启动结果收集器
+    var results []PageInfo
+    done := make(chan struct{})
+    
+    go func() {
+        for page := range c.resultChan {
+            results = append(results, page)
+        }
+        close(done)
+    }()
+    
+    // 等待所有爬取完成
+    c.wg.Wait()
+    close(c.resultChan)
+    
+    // 等待结果收集完成
+    <-done
+    
+    return results
+}
+
+// 保存结果到文件
+func saveResults(results []PageInfo, filename string) error {
+    file, err := os.Create(filename)
+    if err != nil {
+        return err
+    }
+    defer file.Close()
+    
+    for _, page := range results {
+        if page.Error != nil {
+            fmt.Fprintf(file, "URL: %s\n错误: %v\n\n", page.URL, page.Error)
+        } else {
+            fmt.Fprintf(file, "URL: %s\n标题: %s\n链接数: %d\n\n", 
+                page.URL, page.Title, len(page.Links))
+        }
+    }
+    
+    return nil
+}
+
+// 打印统计信息
+func printStats(results []PageInfo) {
+    var successCount, errorCount int
+    var totalLinks int
+    
+    for _, page := range results {
+        if page.Error != nil {
+            errorCount++
+        } else {
+            successCount++
+            totalLinks += len(page.Links)
+        }
+    }
+    
+    fmt.Printf("\n爬取统计:\n")
+    fmt.Printf("成功页面: %d\n", successCount)
+    fmt.Printf("失败页面: %d\n", errorCount)
+    fmt.Printf("总链接数: %d\n", totalLinks)
+    fmt.Printf("平均每页链接数: %.2f\n", float64(totalLinks)/float64(successCount))
+}
+
+func main() {
+    if len(os.Args) < 2 {
+        fmt.Println("使用方法: go run crawler.go <起始URL> [深度] [延迟(秒)]")
+        return
+    }
+    
+    startURL := os.Args[1]
+    maxDepth := 2
+    delay := 1 * time.Second
+    
+    if len(os.Args) >= 3 {
+        fmt.Sscanf(os.Args[2], "%d", &maxDepth)
+    }
+    
+    if len(os.Args) >= 4 {
+        delaySec := 0
+        fmt.Sscanf(os.Args[3], "%d", &delaySec)
+        delay = time.Duration(delaySec) * time.Second
+    }
+    
+    fmt.Printf("开始爬取: %s (深度: %d, 延迟: %v)\n", startURL, maxDepth, delay)
+    
+    // 创建爬虫
+    crawler := NewCrawler(maxDepth, delay)
+    
+    // 开始爬取
+    start := time.Now()
+    results := crawler.Crawl(startURL)
+    duration := time.Since(start)
+    
+    // 打印结果
+    fmt.Printf("\n爬取完成，耗时: %v\n", duration)
+    printStats(results)
+    
+    // 保存结果
+    filename := fmt.Sprintf("crawl_results_%s.txt", time.Now().Format("20060102_150405"))
+    if err := saveResults(results, filename); err != nil {
+        fmt.Printf("保存结果失败: %v\n", err)
+    } else {
+        fmt.Printf("结果已保存到: %s\n", filename)
+    }
+    
+    // 打印前几个结果
+    fmt.Println("\n前5个结果:")
+    count := 0
+    for _, page := range results {
+        if count >= 5 {
+            break
+        }
+        
+        if page.Error != nil {
+            fmt.Printf("%d. %s - 错误: %v\n", count+1, page.URL, page.Error)
+        } else {
+            fmt.Printf("%d. %s - 标题: %s\n", count+1, page.URL, page.Title)
+        }
+        count++
+    }
+}
+```
+
+### 项目3：数据库CRUD应用
+```go
+package main
+
+import (
+    "database/sql"
+    "fmt"
+    "log"
+    "os"
+    "strconv"
+    "strings"
+    "time"
+    
+    _ "github.com/mattn/go-sqlite3"
+)
+
+// 用户模型
+type User struct {
+    ID        int       `json:"id"`
+    Name      string    `json:"name"`
+    Email     string    `json:"email"`
+    Age       int       `json:"age"`
+    Address   string    `json:"address"`
+    CreatedAt time.Time `json:"created_at"`
+    UpdatedAt time.Time `json:"updated_at"`
+}
+
+// 用户服务
+type UserService struct {
+    db *sql.DB
+}
+
+// 创建新的用户服务
+func NewUserService(dbPath string) (*UserService, error) {
+    db, err := sql.Open("sqlite3", dbPath)
+    if err != nil {
+        return nil, err
+    }
+    
+    // 测试连接
+    if err := db.Ping(); err != nil {
+        return nil, err
+    }
+    
+    // 创建表
+    if err := createUserTable(db); err != nil {
+        return nil, err
+    }
+    
+    return &UserService{db: db}, nil
+}
+
+// 创建用户表
+func createUserTable(db *sql.DB) error {
+    query := `
+    CREATE TABLE IF NOT EXISTS users (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        name TEXT NOT NULL,
+        email TEXT UNIQUE NOT NULL,
+        age INTEGER,
+        address TEXT,
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+        updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+    )`
+    
+    _, err := db.Exec(query)
+    return err
+}
+
+// 创建用户
+func (us *UserService) CreateUser(user User) (int, error) {
+    query := `
+    INSERT INTO users (name, email, age, address) 
+    VALUES (?, ?, ?, ?)
+    `
+    
+    result, err := us.db.Exec(query, user.Name, user.Email, user.Age, user.Address)
+    if err != nil {
+        return 0, fmt.Errorf("创建用户失败: %v", err)
+    }
+    
+    id, err := result.LastInsertId()
+    if err != nil {
+        return 0, fmt.Errorf("获取用户ID失败: %v", err)
+    }
+    
+    return int(id), nil
+}
+
+// 根据ID获取用户
+func (us *UserService) GetUser(id int) (User, error) {
+    query := `
+    SELECT id, name, email, age, address, created_at, updated_at 
+    FROM users 
+    WHERE id = ?
+    `
+    
+    var user User
+    err := us.db.QueryRow(query, id).Scan(
+        &user.ID, &user.Name, &user.Email, &user.Age, 
+        &user.Address, &user.CreatedAt, &user.UpdatedAt)
+    
+    if err != nil {
+        if err == sql.ErrNoRows {
+            return User{}, fmt.Errorf("用户不存在")
+        }
+        return User{}, fmt.Errorf("获取用户失败: %v", err)
+    }
+    
+    return user, nil
+}
+
+// 根据邮箱获取用户
+func (us *UserService) GetUserByEmail(email string) (User, error) {
+    query := `
+    SELECT id, name, email, age, address, created_at, updated_at 
+    FROM users 
+    WHERE email = ?
+    `
+    
+    var user User
+    err := us.db.QueryRow(query, email).Scan(
+        &user.ID, &user.Name, &user.Email, &user.Age, 
+        &user.Address, &user.CreatedAt, &user.UpdatedAt)
+    
+    if err != nil {
+        if err == sql.ErrNoRows {
+            return User{}, fmt.Errorf("用户不存在")
+        }
+        return User{}, fmt.Errorf("获取用户失败: %v", err)
+    }
+    
+    return user, nil
+}
+
+// 更新用户
+func (us *UserService) UpdateUser(user User) error {
+    query := `
+    UPDATE users 
+    SET name = ?, email = ?, age = ?, address = ?, updated_at = ? 
+    WHERE id = ?
+    `
+    
+    _, err := us.db.Exec(query, user.Name, user.Email, user.Age, user.Address, time.Now(), user.ID)
+    if err != nil {
+        return fmt.Errorf("更新用户失败: %v", err)
+    }
+    
+    return nil
+}
+
+// 删除用户
+func (us *UserService) DeleteUser(id int) error {
+    query := `DELETE FROM users WHERE id = ?`
+    
+    result, err := us.db.Exec(query, id)
+    if err != nil {
+        return fmt.Errorf("删除用户失败: %v", err)
+    }
+    
+    rowsAffected, err := result.RowsAffected()
+    if err != nil {
+        return fmt.Errorf("获取影响行数失败: %v", err)
+    }
+    
+    if rowsAffected == 0 {
+        return fmt.Errorf("用户不存在")
+    }
+    
+    return nil
+}
+
+// 获取所有用户
+func (us *UserService) ListUsers() ([]User, error) {
+    query := `
+    SELECT id, name, email, age, address, created_at, updated_at 
+    FROM users 
+    ORDER BY id
+    `
+    
+    rows, err := us.db.Query(query)
+    if err != nil {
+        return nil, fmt.Errorf("查询用户失败: %v", err)
+    }
+    defer rows.Close()
+    
+    var users []User
+    for rows.Next() {
+        var user User
+        err := rows.Scan(
+            &user.ID, &user.Name, &user.Email, &user.Age, 
+            &user.Address, &user.CreatedAt, &user.UpdatedAt)
+        
+        if err != nil {
+            return nil, fmt.Errorf("扫描用户数据失败: %v", err)
+        }
+        
+        users = append(users, user)
+    }
+    
+    if err = rows.Err(); err != nil {
+        return nil, fmt.Errorf("遍历用户数据失败: %v", err)
+    }
+    
+    return users, nil
+}
+
+// 搜索用户
+func (us *UserService) SearchUsers(keyword string) ([]User, error) {
+    query := `
+    SELECT id, name, email, age, address, created_at, updated_at 
+    FROM users 
+    WHERE name LIKE ? OR email LIKE ? OR address LIKE ?
+    ORDER BY id
+    `
+    
+    searchPattern := "%" + keyword + "%"
+    
+    rows, err := us.db.Query(query, searchPattern, searchPattern, searchPattern)
+    if err != nil {
+        return nil, fmt.Errorf("搜索用户失败: %v", err)
+    }
+    defer rows.Close()
+    
+    var users []User
+    for rows.Next() {
+        var user User
+        err := rows.Scan(
+            &user.ID, &user.Name, &user.Email, &user.Age, 
+            &user.Address, &user.CreatedAt, &user.UpdatedAt)
+        
+        if err != nil {
+            return nil, fmt.Errorf("扫描用户数据失败: %v", err)
+        }
+        
+        users = append(users, user)
+    }
+    
+    if err = rows.Err(); err != nil {
+        return nil, fmt.Errorf("遍历用户数据失败: %v", err)
+    }
+    
+    return users, nil
+}
+
+// 获取用户统计信息
+func (us *UserService) GetUserStats() (map[string]int, error) {
+    stats := make(map[string]int)
+    
+    // 总用户数
+    var totalUsers int
+    err := us.db.QueryRow("SELECT COUNT(*) FROM users").Scan(&totalUsers)
+    if err != nil {
+        return nil, fmt.Errorf("获取总用户数失败: %v", err)
+    }
+    stats["total"] = totalUsers
+    
+    // 按年龄段统计
+    ageGroups := []struct {
+        name  string
+        query string
+    }{
+        {"young", "SELECT COUNT(*) FROM users WHERE age < 18"},
+        {"adult", "SELECT COUNT(*) FROM users WHERE age BETWEEN 18 AND 60"},
+        {"senior", "SELECT COUNT(*) FROM users WHERE age > 60"},
+    }
+    
+    for _, group := range ageGroups {
+        var count int
+        err := us.db.QueryRow(group.query).Scan(&count)
+        if err != nil {
+            return nil, fmt.Errorf("获取%s用户数失败: %v", group.name, err)
+        }
+        stats[group.name] = count
+    }
+    
+    return stats, nil
+}
+
+// 关闭数据库连接
+func (us *UserService) Close() error {
+    return us.db.Close()
+}
+
+// 显示菜单
+func showMenu() {
+    fmt.Println("\n===== 用户管理系统 =====")
+    fmt.Println("1. 创建用户")
+    fmt.Println("2. 查看用户")
+    fmt.Println("3. 更新用户")
+    fmt.Println("4. 删除用户")
+    fmt.Println("5. 列出所有用户")
+    fmt.Println("6. 搜索用户")
+    fmt.Println("7. 用户统计")
+    fmt.Println("8. 退出")
+    fmt.Print("请选择操作: ")
+}
+
+// 读取用户输入
+func readInput(prompt string) string {
+    fmt.Print(prompt)
+    var input string
+    fmt.Scanln(&input)
+    return strings.TrimSpace(input)
+}
+
+// 读取整数输入
+func readIntInput(prompt string) int {
+    for {
+        input := readInput(prompt)
+        value, err := strconv.Atoi(input)
+        if err != nil {
+            fmt.Println("请输入有效的整数")
+            continue
+        }
+        return value
+    }
+}
+
+func main() {
+    // 创建用户服务
+    userService, err := NewUserService("./users.db")
+    if err != nil {
+        log.Fatalf("创建用户服务失败: %v", err)
+    }
+    defer userService.Close()
+    
+    fmt.Println("欢迎使用用户管理系统")
+    
+    for {
+        showMenu()
+        choice := readInput("")
+        
+        switch choice {
+        case "1":
+            // 创建用户
+            name := readInput("姓名: ")
+            email := readInput("邮箱: ")
+            age := readIntInput("年龄: ")
+            address := readInput("地址: ")
+            
+            user := User{
+                Name:    name,
+                Email:   email,
+                Age:     age,
+                Address: address,
+            }
+            
+            id, err := userService.CreateUser(user)
+            if err != nil {
+                fmt.Printf("创建用户失败: %v\n", err)
+            } else {
+                fmt.Printf("用户创建成功，ID: %d\n", id)
+            }
+            
+        case "2":
+            // 查看用户
+            id := readIntInput("用户ID: ")
+            user, err := userService.GetUser(id)
+            if err != nil {
+                fmt.Printf("获取用户失败: %v\n", err)
+            } else {
+                fmt.Printf("ID: %d\n", user.ID)
+                fmt.Printf("姓名: %s\n", user.Name)
+                fmt.Printf("邮箱: %s\n", user.Email)
+                fmt.Printf("年龄: %d\n", user.Age)
+                fmt.Printf("地址: %s\n", user.Address)
+                fmt.Printf("创建时间: %s\n", user.CreatedAt.Format("2006-01-02 15:04:05"))
+            }
+            
+        case "3":
+            // 更新用户
+            id := readIntInput("用户ID: ")
+            
+            // 先获取现有用户信息
+            user, err := userService.GetUser(id)
+            if err != nil {
+                fmt.Printf("获取用户失败: %v\n", err)
+                continue
+            }
+            
+            fmt.Println("当前用户信息:")
+            fmt.Printf("姓名: %s\n", user.Name)
+            fmt.Printf("邮箱: %s\n", user.Email)
+            fmt.Printf("年龄: %d\n", user.Age)
+            fmt.Printf("地址: %s\n", user.Address)
+            
+            // 获取新信息
+            name := readInput("新姓名 (留空保持不变): ")
+            if name != "" {
+                user.Name = name
+            }
+            
+            email := readInput("新邮箱 (留空保持不变): ")
+            if email != "" {
+                user.Email = email
+            }
+            
+            ageInput := readInput("新年龄 (留空保持不变): ")
+            if ageInput != "" {
+                age, err := strconv.Atoi(ageInput)
+                if err == nil {
+                    user.Age = age
+                }
+            }
+            
+            address := readInput("新地址 (留空保持不变): ")
+            if address != "" {
+                user.Address = address
+            }
+            
+            if err := userService.UpdateUser(user); err != nil {
+                fmt.Printf("更新用户失败: %v\n", err)
+            } else {
+                fmt.Println("用户更新成功")
+            }
+            
+        case "4":
+            // 删除用户
+            id := readIntInput("用户ID: ")
+            
+            // 确认删除
+            confirm := readInput(fmt.Sprintf("确定要删除ID为%d的用户吗? (y/n): ", id))
+            if strings.ToLower(confirm) == "y" {
+                if err := userService.DeleteUser(id); err != nil {
+                    fmt.Printf("删除用户失败: %v\n", err)
+                } else {
+                    fmt.Println("用户删除成功")
+                }
+            } else {
+                fmt.Println("取消删除")
+            }
+            
+        case "5":
+            // 列出所有用户
+            users, err := userService.ListUsers()
+            if err != nil {
+                fmt.Printf("获取用户列表失败: %v\n", err)
+                continue
+            }
+            
+            if len(users) == 0 {
+                fmt.Println("没有用户")
+                continue
+            }
+            
+            fmt.Println("\n用户列表:")
+            fmt.Println("ID\t姓名\t邮箱\t年龄")
+            for _, user := range users {
+                fmt.Printf("%d\t%s\t%s\t%d\n", user.ID, user.Name, user.Email, user.Age)
+            }
+            
+        case "6":
+            // 搜索用户
+            keyword := readInput("搜索关键词: ")
+            users, err := userService.SearchUsers(keyword)
+            if err != nil {
+                fmt.Printf("搜索用户失败: %v\n", err)
+                continue
+            }
+            
+            if len(users) == 0 {
+                fmt.Println("没有找到匹配的用户")
+                continue
+            }
+            
+            fmt.Printf("\n找到%d个匹配的用户:\n", len(users))
+            fmt.Println("ID\t姓名\t邮箱\t年龄")
+            for _, user := range users {
+                fmt.Printf("%d\t%s\t%s\t%d\n", user.ID, user.Name, user.Email, user.Age)
+            }
+            
+        case "7":
+            // 用户统计
+            stats, err := userService.GetUserStats()
+            if err != nil {
+                fmt.Printf("获取用户统计失败: %v\n", err)
+                continue
+            }
+            
+            fmt.Println("\n用户统计:")
+            fmt.Printf("总用户数: %d\n", stats["total"])
+            fmt.Printf("青少年用户 (<18岁): %d\n", stats["young"])
+            fmt.Printf("成年用户 (18-60岁): %d\n", stats["adult"])
+            fmt.Printf("老年用户 (>60岁): %d\n", stats["senior"])
+            
+        case "8":
+            // 退出
+            fmt.Println("感谢使用用户管理系统，再见!")
+            return
+            
+        default:
+            fmt.Println("无效的选择，请重新输入")
+        }
+    }
+}
 ```
 
 ## 推荐资源

me/1_helloword.go

@@ -0,0 +1,5 @@
+package main
+import "fmt"
+func main() { 
+	fmt.Println("Hello, World!")
+}