// 通用格式
func 函數(shù)名(參數(shù)列表) 返回值列表 {
    // 函數(shù)體
}

// 普通多返回值：計(jì)算和與差
func calc(a, b int) (int, int) {
    return a + b, a - b
}

// 命名返回值：計(jì)算乘積與商（避免返回值順序混淆）
func multiplyAndDivide(a, b int) (product int, quotient int) {
    product = a * b
    if b != 0 {
        quotient = a / b
    }
    return // 直接返回命名變量，無需顯式傳值
}

func main() {
    sum, _ := calc(10, 5) // 忽略“差”的返回值
    fmt.Println("和：", sum) // 輸出：和：15
}

package main

import "fmt"

func main() {
    // 直接傳入多個(gè)值
    total1 := getSum(10, 20, 30)
    fmt.Println("總和1：", total1) // 輸出：總和1：60

    // 傳遞切片（需加...）
    nums := []int{40, 50, 60}
    total2 := getSum(nums...)
    fmt.Println("總和2：", total2) // 輸出：總和2：150
}

// 可變參數(shù)求和：nums...int 表示接收任意個(gè)int類型參數(shù)
func getSum(nums ...int) int {
    sum := 0
    fmt.Printf("參數(shù)個(gè)數(shù)：%d\n", len(nums)) // 輸出參數(shù)總數(shù)
    for i, v := range nums { // 遍歷可變參數(shù)（切片）
        fmt.Printf("參數(shù)%d：%d\n", i, v)
        sum += v
    }
    return sum
}

package main

import "fmt"

func main() {
    x := 10 // 函數(shù)內(nèi)局部變量
    if x > 5 {
        x := 20 // 代碼塊內(nèi)局部變量（與外層x同名）
        fmt.Println("if塊內(nèi)x：", x) // 輸出：20（就近原則）
    }
    fmt.Println("main函數(shù)內(nèi)x：", x) // 輸出：10（外層x未被修改）
}

package main

import "fmt"

// 全局變量：包內(nèi)所有函數(shù)可訪問
var globalCount int = 0

func main() {
    increment()
    increment()
    fmt.Println("全局計(jì)數(shù)：", globalCount) // 輸出：2
}

func increment() {
    globalCount++ // 訪問并修改全局變量
}

package main

import "fmt"

func main() {
    result := factorial(5)
    fmt.Println("5的階乘：", result) // 輸出：120
}

// 遞歸函數(shù)：計(jì)算n!
func factorial(n int) int {
    // 終止條件：n=1時(shí)返回1（1! = 1）
    if n == 1 {
        return 1
    }
    // 遞推關(guān)系：n! = n * (n-1)!
    return n * factorial(n-1)
}

package main

import "fmt"

func main() {
    fmt.Println("1")
    defer fmt.Println("2") // 第1個(gè)defer
    defer fmt.Println("3") // 第2個(gè)defer（后定義，先執(zhí)行）
    fmt.Println("4")
    // 執(zhí)行順序：1 → 4 → 3 → 2
}

package main

import "fmt"

func main() {
    n := 10
    // defer定義時(shí)，參數(shù)n的值已確定為10（即使后續(xù)n修改，也不影響）
    defer fmt.Println("defer內(nèi)n：", n) 
    n = 20
    fmt.Println("main內(nèi)n：", n) // 輸出：main內(nèi)n：20
    // 最終輸出：main內(nèi)n：20 → defer內(nèi)n：10
}

package main

import (
    "fmt"
    "os"
)

func main() {
    // 打開文件
    file, err := os.Open("test.txt")
    if err != nil {
        fmt.Println("文件打開失敗：", err)
        return
    }
    // 延遲關(guān)閉文件：確保函數(shù)返回前執(zhí)行，避免資源泄漏
    defer file.Close()

    // 后續(xù)文件讀寫操作...
    fmt.Println("文件打開成功")
}

// 示例：接收兩個(gè)int、返回一個(gè)int的函數(shù)類型
func(int, int) int

package main

import "fmt"

func main() {
    // 1. 將函數(shù)賦值給變量（函數(shù)名不加()，表示函數(shù)本身，而非調(diào)用）
    var addFunc func(int, int) int = add
    // 2. 通過變量調(diào)用函數(shù)
    result := addFunc(3, 5)
    fmt.Println("3+5 =", result) // 輸出：8

    // 簡(jiǎn)化寫法：類型推導(dǎo)
    subFunc := sub
    fmt.Println("10-4 =", subFunc(10, 4)) // 輸出：6
}

// 加法函數(shù)
func add(a, b int) int {
    return a + b
}

// 減法函數(shù)
func sub(a, b int) int {
    return a - b
}

package main

import "fmt"

func main() {
    // 1. 傳遞已定義的函數(shù)（加法、減法）
    sum := calculate(10, 5, add)
    diff := calculate(10, 5, sub)
    fmt.Println("10+5 =", sum)  // 輸出：15
    fmt.Println("10-5 =", diff) // 輸出：5

    // 2. 傳遞匿名函數(shù)（乘法、除法）
    product := calculate(10, 5, func(a, b int) int {
        return a * b
    })
    quotient := calculate(10, 5, func(a, b int) int {
        if b == 0 {
            fmt.Println("除數(shù)不能為0")
            return 0
        }
        return a / b
    })
    fmt.Println("10*5 =", product)  // 輸出：50
    fmt.Println("10/5 =", quotient) // 輸出：2
}

// 高階函數(shù)：接收兩個(gè)int和一個(gè)回調(diào)函數(shù)，返回計(jì)算結(jié)果
func calculate(a, b int, op func(int, int) int) int {
    return op(a, b) // 調(diào)用回調(diào)函數(shù)
}

// 加法回調(diào)函數(shù)
func add(a, b int) int {
    return a + b
}

// 減法回調(diào)函數(shù)
func sub(a, b int) int {
    return a - b
}

package main

import "fmt"

func main() {
    // 1. 創(chuàng)建第一個(gè)計(jì)數(shù)器（閉包1）
    counter1 := newCounter()
    fmt.Println(counter1()) // 輸出：1
    fmt.Println(counter1()) // 輸出：2

    // 2. 創(chuàng)建第二個(gè)計(jì)數(shù)器（閉包2，與counter1獨(dú)立）
    counter2 := newCounter()
    fmt.Println(counter2()) // 輸出：1（不受counter1影響）
    fmt.Println(counter1()) // 輸出：3（counter1繼續(xù)自增）
}

// 外層函數(shù)：返回一個(gè)計(jì)數(shù)器函數(shù)（內(nèi)層函數(shù)）
func newCounter() func() int {
    // 外層函數(shù)的局部變量：僅閉包內(nèi)可訪問，避免全局污染
    count := 0

    // 內(nèi)層函數(shù)：引用外層變量count
    return func() int {
        count++
        return count
    }
}

package main

import "fmt"

func main() {
    arr := [3]int{1, 2, 3}
    fmt.Println("修改前：", arr) // 輸出：[1 2 3]
    modifyArray(arr)
    fmt.Println("修改后：", arr) // 輸出：[1 2 3]（原數(shù)組未變）
}

// 函數(shù)內(nèi)修改的是數(shù)組副本
func modifyArray(a [3]int) {
    a[0] = 100
    fmt.Println("函數(shù)內(nèi)：", a) // 輸出：[100 2 3]
}

package main
import "fmt"
func main() {
    slice := []int{1, 2, 3}
    fmt.Println("修改前：", slice) // 輸出：[1 2 3]
    modifySlice(slice)
    fmt.Println("修改后：", slice) // 輸出：[100 2 3]（原切片被修改）
}

// 函數(shù)內(nèi)通過地址修改原切片數(shù)據(jù)
func modifySlice(s []int) {
    s[0] = 100
    fmt.Println("函數(shù)內(nèi)：", s) // 輸出：[100 2 3]
}