← 返回首页

函数

基本函数定义

package main

import "fmt"

// 无参数无返回值的函数
func sayHello() {
    fmt.Println("Hello, World!")
}

// 有参数的函数
func greet(name string) {
    fmt.Printf("Hello, %s!\n", name)
}

// 有返回值的函数
func add(a, b int) int {
    return a + b
}

// 多个返回值
func divide(a, b int) (int, error) {
    if b == 0 {
        return 0, fmt.Errorf("除数不能为零")
    }
    return a / b, nil
}

func main() {
    sayHello()
    greet("Go")

    result := add(5, 3)
    fmt.Println("5 + 3 =", result)

    quotient, err := divide(10, 2)
    if err != nil {
        fmt.Println("错误:", err)
    } else {
        fmt.Println("10 / 2 =", quotient)
    }
}

命名返回值

package main

import "fmt"

// 命名返回值
func split(sum int) (x, y int) {
    x = sum * 4 / 9
    y = sum - x
    return // 隐式返回
}

func main() {
    a, b := split(17)
    fmt.Println("x:", a, "y:", b)
}

可变参数函数

package main

import "fmt"

// 可变参数函数
func sum(numbers ...int) int {
    total := 0
    for _, num := range numbers {
        total += num
    }
    return total
}

// 混合参数
func printInfo(prefix string, values ...int) {
    fmt.Print(prefix, ": ")
    for _, v := range values {
        fmt.Print(v, " ")
    }
    fmt.Println()
}

func main() {
    fmt.Println(sum(1, 2, 3))
    fmt.Println(sum(1, 2, 3, 4, 5))

    // 传递切片
    nums := []int{10, 20, 30}
    fmt.Println(sum(nums...))

    printInfo("数字", 1, 2, 3)
}

匿名函数和闭包

package main

import "fmt"

func main() {
    // 匿名函数
    func() {
        fmt.Println("匿名函数")
    }()

    // 带参数的匿名函数
    func(name string) {
        fmt.Println("Hello,", name)
    }("Go")

    // 匿名函数作为值
    add := func(a, b int) int {
        return a + b
    }
    fmt.Println(add(5, 3))

    // 闭包
    // 函数可以访问外部变量
    number := 10

    func() {
        fmt.Println("闭包访问外部变量:", number)
    }()

    // 闭包函数工厂
    adder := func() func(int) int {
        sum := 0
        return func(x int) int {
            sum += x
            return sum
        }
    }

    pos, neg := adder(), adder()
    for i := 0; i < 3; i++ {
        fmt.Println(pos(i), neg(-2*i))
    }
}

函数作为参数和返回值

package main

import "fmt"

// 函数类型
type operation func(int, int) int

// 函数作为参数
func calculate(a, b int, op operation) int {
    return op(a, b)
}

// 函数作为返回值
func getOperation(op string) operation {
    switch op {
    case "add":
        return func(a, b int) int {
            return a + b
        }
    case "subtract":
        return func(a, b int) int {
            return a - b
        }
    default:
        return nil
    }
}

func main() {
    // 使用函数作为参数
    add := func(a, b int) int { return a + b }
    multiply := func(a, b int) int { return a * b }

    fmt.Println("10 + 5 =", calculate(10, 5, add))
    fmt.Println("10 * 5 =", calculate(10, 5, multiply))

    // 使用函数作为返回值
    op := getOperation("add")
    if op != nil {
        fmt.Println("操作结果:", op(3, 4))
    }
}

defer 函数调用

package main

import "fmt"

func main() {
    // defer 与返回值
    result := deferExample()
    fmt.Println("结果:", result)
}

func deferExample() (result int) {
    defer func() {
        result *= 2
        fmt.Println("defer 中修改返回值:", result)
    }()

    result = 10
    fmt.Println("返回前:", result)
    return result
}

方法

方法是带有接收者的函数。

package main

import "fmt"

// 定义结构体
type Rectangle struct {
    width, height float64
}

// 值接收者方法
func (r Rectangle) Area() float64 {
    return r.width * r.height
}

// 指针接收者方法
func (r *Rectangle) Scale(factor float64) {
    r.width *= factor
    r.height *= factor
}

func main() {
    rect := Rectangle{width: 3, height: 4}

    fmt.Printf("面积: %.2f\n", rect.Area())

    rect.Scale(2)
    fmt.Printf("缩放后面积: %.2f\n", rect.Area())
}