函数

在 Go 中，使用 func 关键字定义函数。

func greet() {
    fmt.Println("Hello!")
}

Go 函数的特性使其在语言的简洁性、效率和可读性方面独具特色。

多返回值

Go 允许函数返回多个值。

func nums() (int, int) {
    return 5, 8
}

命名返回值

Go 允许在函数签名中为返回值命名。这对于标示每个返回值的目的并提高代码可读性比较有用。

func divideAndRemainder(dividend, divisor int) (quotient, remainder int) {
    quotient = dividend / divisor
    remainder = dividend % divisor
    return
}

由于返回值已经有了名称，你不需要在语句中显式地 return 它们。只需单独使用 return 关键字即可。

变参函数

Go 允许你使用省略号（...）语法创建接受可变数量参数的函数。当参数数量事先未知时，这非常有用。

package main

import "fmt"

func sum(numbers ...int) int {
    total := 0
    for _, num := range numbers {
        total += num
    }
    return total
}

func main() {
    result := sum(1, 2, 3, 4, 5)
    fmt.Println(result)
}

匿名函数

Go 支持匿名函数，可以形成闭包。它们是没有名字的函数，可以在行内定义并调用。闭包特别适用于封装功能和创建简洁的代码。

package main

import "fmt"

func makeIntFunc() func() int {
    i := 0
    return func() int {
        i++
        return i
    }
}

func main() {

    nextInt := makeIntFunc()

    fmt.Println(nextInt())
    fmt.Println(nextInt())
    fmt.Println(nextInt())

    newInts := makeIntFunc()
    fmt.Println(newInts())
}

递归

递归是函数直接或间接调用自身的过程。

package main

import "fmt"

func factorial(n int) int {
    if n <= 0 {
        return 1
    }
    return n * factorial(n-1)
}

func main() {
    // 计算 5 的阶乘
    result := factorial(5)
    fmt.Printf("Factorial of 5 is: %d\n", result)
    // => Factorial of 5 is: 120
}

方法

在 Go 中，方法是与特定类型关联的函数。它们类似于函数，但定义时有一个接收者，该接收者是与类型相关的参数。

package main

import "fmt"

type Circle struct {
    Radius float64
}

// 与 Circle 类型相关联的方法
func (c Circle) Area() float64 {
    return 3.14 * c.Radius * c.Radius
}

func main() {
    myCircle := Circle{Radius: 5.0}

    // 在 Circle 实例上调用方法
    area := myCircle.Area()

    fmt.Printf("Area of the circle: %.2f\n", area)
    // => Area of the circle: 78.50
}

一等公民

Go 将函数视为一等公民，这意味着你可以将它们作为参数传递给其他函数，从函数返回它们，并将它们赋值给变量。

package main

import "fmt"

func apply(operation func(int, int) int, a, b int) int {
    return operation(a, b)
}

func add(a, b int) int {
    return a + b
}

func main() {
    result := apply(add, 3, 4)
    fmt.Println(result)
}

函数排序

使用 sort.Slice 函数对数值切片进行排序。

package main

import (
	"fmt"
	"sort"
)

func main() {
	numbers := []int{5, 2, 9, 1, 5, 6}

	// 使用自定义排序函数对切片进行排序
	sort.Slice(numbers, func(i, j int) bool {
		return numbers[i] > numbers[j]
	})

	fmt.Println("Sorted slice:", numbers)
    // => Sorted slice: [9 6 5 5 2 1]
}

sort.Slice 的第二个参数是一个定义排序顺序的函数。在该示例中，它是一个简单的匿名函数，比较两个元素，如果索引 i 处的元素大于索引 j 处的元素，则返回 true。

代码挑战

编写一个 Go 程序，定义一个名为 createCounter 的函数，该函数返回一个闭包。 该闭包是一个计数器，每次调用时都会增加计数值并返回计数。