Golang函数的使用技巧(结合代码示例)

// 通用格式
func 函数名(参数列表) 返回值列表 {
    // 函数体
}

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

// 命名返回值：计算乘积与商（避免返回值顺序混淆）
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() {
    // 直接传入多个值
    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
}

// 可变参数求和：nums...int 表示接收任意个int类型参数
func getSum(nums ...int) int {
    sum := 0
    fmt.Printf("参数个数：%d\n", len(nums)) // 输出参数总数
    for i, v := range nums { // 遍历可变参数（切片）
        fmt.Printf("参数%d：%d\n", i, v)
        sum += v
    }
    return sum
}

package main

import "fmt"

func main() {
    x := 10 // 函数内局部变量
    if x > 5 {
        x := 20 // 代码块内局部变量（与外层x同名）
        fmt.Println("if块内x：", x) // 输出：20（就近原则）
    }
    fmt.Println("main函数内x：", x) // 输出：10（外层x未被修改）
}

package main

import "fmt"

// 全局变量：包内所有函数可访问
var globalCount int = 0

func main() {
    increment()
    increment()
    fmt.Println("全局计数：", globalCount) // 输出：2
}

func increment() {
    globalCount++ // 访问并修改全局变量
}

package main

import "fmt"

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

// 递归函数：计算n!
func factorial(n int) int {
    // 终止条件：n=1时返回1（1! = 1）
    if n == 1 {
        return 1
    }
    // 递推关系：n! = n * (n-1)!
    return n * factorial(n-1)
}

package main

import "fmt"

func main() {
    fmt.Println("1")
    defer fmt.Println("2") // 第1个defer
    defer fmt.Println("3") // 第2个defer（后定义，先执行）
    fmt.Println("4")
    // 执行顺序：1 → 4 → 3 → 2
}

package main

import "fmt"

func main() {
    n := 10
    // defer定义时，参数n的值已确定为10（即使后续n修改，也不影响）
    defer fmt.Println("defer内n：", n) 
    n = 20
    fmt.Println("main内n：", n) // 输出：main内n：20
    // 最终输出：main内n：20 → defer内n：10
}

package main

import (
    "fmt"
    "os"
)

func main() {
    // 打开文件
    file, err := os.Open("test.txt")
    if err != nil {
        fmt.Println("文件打开失败：", err)
        return
    }
    // 延迟关闭文件：确保函数返回前执行，避免资源泄漏
    defer file.Close()

    // 后续文件读写操作...
    fmt.Println("文件打开成功")
}

// 示例：接收两个int、返回一个int的函数类型
func(int, int) int

package main

import "fmt"

func main() {
    // 1. 将函数赋值给变量（函数名不加()，表示函数本身，而非调用）
    var addFunc func(int, int) int = add
    // 2. 通过变量调用函数
    result := addFunc(3, 5)
    fmt.Println("3+5 =", result) // 输出：8

    // 简化写法：类型推导
    subFunc := sub
    fmt.Println("10-4 =", subFunc(10, 4)) // 输出：6
}

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

// 减法函数
func sub(a, b int) int {
    return a - b
}

package main

import "fmt"

func main() {
    // 1. 传递已定义的函数（加法、减法）
    sum := calculate(10, 5, add)
    diff := calculate(10, 5, sub)
    fmt.Println("10+5 =", sum)  // 输出：15
    fmt.Println("10-5 =", diff) // 输出：5

    // 2. 传递匿名函数（乘法、除法）
    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("除数不能为0")
            return 0
        }
        return a / b
    })
    fmt.Println("10*5 =", product)  // 输出：50
    fmt.Println("10/5 =", quotient) // 输出：2
}

// 高阶函数：接收两个int和一个回调函数，返回计算结果
func calculate(a, b int, op func(int, int) int) int {
    return op(a, b) // 调用回调函数
}

// 加法回调函数
func add(a, b int) int {
    return a + b
}

// 减法回调函数
func sub(a, b int) int {
    return a - b
}

package main

import "fmt"

func main() {
    // 1. 创建第一个计数器（闭包1）
    counter1 := newCounter()
    fmt.Println(counter1()) // 输出：1
    fmt.Println(counter1()) // 输出：2

    // 2. 创建第二个计数器（闭包2，与counter1独立）
    counter2 := newCounter()
    fmt.Println(counter2()) // 输出：1（不受counter1影响）
    fmt.Println(counter1()) // 输出：3（counter1继续自增）
}

// 外层函数：返回一个计数器函数（内层函数）
func newCounter() func() int {
    // 外层函数的局部变量：仅闭包内可访问，避免全局污染
    count := 0

    // 内层函数：引用外层变量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]（原数组未变）
}

// 函数内修改的是数组副本
func modifyArray(a [3]int) {
    a[0] = 100
    fmt.Println("函数内：", 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]（原切片被修改）
}

// 函数内通过地址修改原切片数据
func modifySlice(s []int) {
    s[0] = 100
    fmt.Println("函数内：", s) // 输出：[100 2 3]
}