go 函数

go 函数

函数定义

在Go中，函数是一种基本的代码块，用于执行特定的任务。函数在Go中被定义为一个代码块，具有名称和一些参数，可以接受并返回值。函数定义如下：

func function_name(parameter_name type) return_type {
    // 函数体
    return value
}

其中，func是关键字，function_name是函数的名称，parameter_name是参数的名称，type是参数的数据类型，return_type是函数的返回类型，value是函数返回的值。

Go函数的特点如下

• 支持多返回值：Go语言的函数可以返回多个值，这样可以方便地返回多个计算结果或者同时处理多个返回值。
• 命名返回值：可以在函数定义时给返回值命名，使得函数内部可以直接使用这些变量，并且在函数结束时，可以通过简单的return语句来返回这些已命名的值。
• 支持可变参数：Go语言允许函数接受可变数量的参数。通过使用...语法，函数可以接受任意数量的相同类型参数。
• 支持defer语句：defer语句用于在函数执行完毕后，延迟执行指定的代码块。这在需要在函数返回前执行一些清理或资源释放操作时非常有用。
• 可以有多个return语句，但是只是会执行其中一个，执行后就会返回。
• 递归支持：Go语言支持递归函数，可以在函数体内调用自己，用于解决一些需要重复执行的问题。
• 支持错误处理：函数可以返回错误信息，用于指示函数执行中是否发生错误。Go鼓励使用多返回值来返回函数执行状态以及错误信息，以实现更可靠的错误处理机制。
• 函数作为一等公民：在Go语言中，函数可以像其他变量一样进行传递、赋值和作为参数传递给其他函数，作为返回值，这使得函数在Go中具有更强大的表现力和灵活性。
• 支持匿名函数和闭包：Go语言支持在函数内部定义匿名函数，并且这些函数可以捕获外部函数的局部变量，形成闭包。匿名函数是指没有名称的函数，可以直接将其赋值给变量或直接调用。
• 支持函数闭包：在Go中，可以在一个函数中定义另一个函数，内部函数可以访问外部函数的局部变量。这种特性被称为函数闭包，它可以用于实现一些更为复杂的逻辑和功能。闭包是指一个函数可以访问其外部作用域中的变量，即使该变量在函数外部也可以访问。

函数作为参数

在Go语言中，函数是一等公民，这意味着函数可以像其他变量一样被传递给其他函数，作为参数传递给其他函数。这样的特性使得函数更加灵活和强大，可以实现更为复杂的逻辑和功能。

在Go中，函数可以被声明为类型，例如：

type MyFunction func(int, int) int

上面的代码中，MyFunction被声明为一个函数类型，它接受两个int类型的参数并返回一个int类型的值。

然后，我们可以在其他函数中使用这个函数类型作为参数，例如：

func calculate(a, b int, op MyFunction) int {
    return op(a, b)
}

在这个例子中，calculate函数接受三个参数：两个int类型的数值a和b，还有一个函数类型op。该函数类型op的签名必须和MyFunction相同，接受两个int类型参数并返回一个int类型值。函数calculate会将a和b作为参数传递给op函数，并返回op函数的结果。

使用示例：

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

func multiply(a, b int) int {
    return a * b
}

func main() {
    result1 := calculate(2, 3, add)       // 使用add函数进行加法运算，结果为5
    result2 := calculate(2, 3, multiply)  // 使用multiply函数进行乘法运算，结果为6
    fmt.Println(result1, result2)
}

在上面的示例中，我们声明了add和multiply两个函数，并在main函数中使用calculate函数来执行加法和乘法运算，通过将不同的函数作为参数传递给calculate函数，我们可以轻松地在calculate函数中实现不同的操作，增加了代码的灵活性和可复用性。

函数作为参数的特性在Go语言中非常常用，它允许我们以一种通用的方式编写函数，以便在不同的场景下重用这些函数，并通过传递不同的函数作为参数来实现不同的功能。这种编程风格在编写高阶函数和实现回调机制时特别有用

可变参数

相同类型可变参数

在Go中，可以使用可变参数函数来接受不定数量的参数。这在需要传递不同数量参数的情况下非常有用。例如，fmt.Println() 函数可以接受不定数量的参数并将它们打印到控制台上。在Go中，使用可变参数函数时，需要在函数签名中指定 “…” 符号，表示参数数量不定。

下面是一个示例，演示了如何在Go中使用可变参数函数：

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

func main() {
    fmt.Println(sum(1, 2, 3))    // 输出：6
    fmt.Println(sum(1, 2, 3, 4)) // 输出：10
}

在上面的代码中，函数 sum 声明了一个可变参数 nums，表示可以接受任意数量的整数参数。在函数体内，我们使用 range 遍历了传入的参数，将它们相加后返回总和。

我们可以通过传递任意数量的参数来调用 sum 函数，示例中分别传递了 3 个参数和 4 个参数。函数会将它们全部相加并返回结果。

不同类型可变参数

在 Go 语言中，是可以传递多个不同类型的可变参数的。可以使用 interface{} 类型作为可变参数的类型，它可以表示任意类型的值。

下面是一个例子，展示了如何使用 interface{} 类型作为可变参数的类型，以便传递多个不同类型的值：

func printValues(values ...interface{}) {
    for _, value := range values {
        fmt.Println(value)
    }
}

func main() {
    printValues(1, "two", true)
}

在上面的例子中，printValues 函数的可变参数类型被定义为 interface{}，因此可以接受多个不同类型的值。在 main 函数中，我们传递了三个不同类型的值：整数、字符串和布尔值。在 printValues 函数中，我们使用 range 循环遍历所有传递进来的参数，并使用 fmt.Println 打印每个值。这样，我们就可以打印多个不同类型的值了。

return语句

作用概述

在Go中，return语句用于从函数中返回值并停止函数执行，并把代码的执行权返回给调用者。对于无返回值的函数，函数体末尾的return语句可以直接省略。return语句可以放在函数中的任何位置，并且可以返回零个、一个或多个值。

空的return语句

在无返回值函数（void函数）中，可以使用空的return语句来显式地结束函数的执行。

func doSomething() {
    // 一些操作
    return // 空的return语句表示函数执行结束
}

空白标识符

如果函数有命名返回值，但不打算在函数体中使用它们，可以使用下划线 _ 作为空白标识符表示忽略这些返回值。

func divide(a, b float64) (result float64, err error) {
    // ...
    if b == 0 {
        err = fmt.Errorf("cannot divide by zero")
        return 0, err // 只返回错误，忽略result的返回值
    }
    // ...
    return // 只返回result，忽略err的返回值
}

多个返回值

在函数中，可以返回多个值，例如：

func calculate(a, b int) (int, int, int, float64) {
    sum := a + b
    diff := a - b
    product := a * b
    quotient := float64(a) / float64(b)
    return sum, diff, product, quotient
}

在上面的例子中，calculate函数返回四个值，它们是a和b的和、差、积和商。

命名返回值

在Go中，也可以在函数签名中为返回值指定名称，这些名称被视为函数的局部变量，在函数体中可以直接使用。如果在函数体中没有显式使用return语句，则返回值会自动被返回。例如：

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

在上面的例子中，函数返回类型为int，并且返回值被命名为sum。在函数体中，sum被计算为a和b的和，并通过不带参数的return语句返回。

defer 语句

作用

1. 在Go语言中，defer语句用于延迟执行一个函数调用，通常用于确保在函数执行完毕前进行一些清理操作。defer语句会将函数调用推迟到包含它的函数即将返回之前执行，无论函数是正常返回还是发生了异常
2. 在实际应用中，要确保在执行函数的过程中遇到错误时及时处理一些必要的事情，比如关闭连接、关闭文件等。通常情况下可以使用defer关键字实现这些功能。
3. defer 关键字用于释放资源，会在函数返回之前调用，即便函数崩溃也会在结束之前调用defer。
4. 一个函数内可以有多个defer，在调用时按照栈的方式先进后出，即写在前面的后调用。

引申出来的面试题for defer

下面是一个使用defer的示例代码

package main

import "fmt"

func main() {
    for i := 1; i <= 5; i++ {
        defer fmt.Println(i)
    }
    fmt.Println("Done")
}

输出结果

Done
5
4
3
2
1

在这个示例中，我们使用了一个for循环，并在每次循环迭代时使用defer语句延迟打印变量i的值。当程序执行到defer fmt.Println(i)时，不会立即执行该语句，而是在包含它的函数即将返回之前才执行。因此，打印的结果是逆序的。

需要注意的是，defer语句是按照后进先出（LIFO）的顺序执行的。在示例代码中，我们使用了一个for循环，每次循环迭代都会推迟一个新的defer语句，所以在函数返回前，defer语句会按照逆序执行。

总结起来，使用defer语句可以确保在函数返回前执行一些必要的清理操作，而无需在每个可能的返回点都进行显式的调用。在使用defer语句时需要注意推迟的函数调用的执行顺序，以及可能产生的副作用。

匿名函数

匿名函数是一种在Go语言中可以直接定义且没有函数名的函数。它是一种特殊类型的函数，可以在定义的地方直接使用，而不需要为其分配一个名字。匿名函数在Go中非常常用，特别是在需要传递函数作为参数、或者在闭包中使用时。

定义匿名函数

在Go语言中，定义匿名函数的一般形式为：

func(parameters) returnType {
    // function body
}

其中，parameters表示函数的参数列表，returnType表示函数的返回类型（可以省略），function body表示函数体。

使用匿名函数

匿名函数可以直接在代码中使用，例如：

func main() {
    // 使用匿名函数计算两个数的和
    sum := func(a, b int) int {
        return a + b
    }(2, 3) // 调用匿名函数并传入参数2和3
    fmt.Println(sum) // 输出结果：5
}

在上面的例子中，我们定义了一个匿名函数并直接在代码中调用它，计算两个数的和并将结果存储在变量sum中。

作用

匿名函数主要有两个作用：

1. 作为参数传递：可以将匿名函数作为参数传递给其他函数，从而实现在函数中传递逻辑或行为。
2. 闭包：匿名函数可以捕获外部函数中的变量，形成闭包。这意味着匿名函数可以访问外部函数的局部变量，即使外部函数已经执行完毕。

使用注意事项

在使用匿名函数时，需要注意以下几点：

1. 调用匿名函数：定义匿名函数后，需要在定义后使用小括号()调用函数并传入参数（如果有参数的话）。
2. 作为参数传递：可以将匿名函数作为参数传递给其他函数，以便在函数中执行匿名函数的逻辑。
3. 闭包问题：在使用匿名函数时，尤其是在闭包中使用时，要注意外部变量的生命周期，确保不会出现意外的结果。
4. 函数类型：匿名函数可以赋值给函数类型的变量，以便在其他地方使用。
5. 变量作用域：在匿名函数中可以访问外部函数的局部变量，但要注意变量作用域的问题。

总结：匿名函数是Go语言中的一种强大特性，它可以简化代码并增加程序的灵活性。通过匿名函数，我们可以更加方便地编写高阶函数、实现闭包和实现回调机制，让我们的代码更加优雅和易于维护。但在使用匿名函数时，要特别注意变量作用域和闭包问题，避免出现不必要的错误。

闭包

闭包定义

闭包（Closure）是一个函数值（Function Value），它包含了函数的代码以及该函数的引用环境（变量）。

具体来说，闭包是指在函数内部定义的函数，这个内部函数可以访问其外部函数的局部变量，并且在外部函数的生命周期内都保持有效。闭包可以捕获和存储其外部函数的局部变量，并使得这些变量在内部函数被调用时保持状态。

闭包的特点：

1. 内部函数可以访问外部函数的局部变量。
2. 外部函数的局部变量被内部函数引用后，其生命周期得到延长，直到内部函数不再被引用时才会被销毁。
3. 外部函数返回的是内部函数的函数值。
4. 同一个闭包函数中的变量的生命周期是整个闭包函数的生命周期

闭包的使用场景：

1. 常用于实现一些类似于对象的功能，隐藏了内部的状态信息，只提供对外暴露的方法。
2. 用于实现回调机制，将函数作为参数传递给其他函数。

以下是一个使用闭包的示例代码：

package main

import "fmt"

func adder() func(int) int {
    sum := 0 // 外部函数的局部变量
    return func(x int) int {
        sum += x // 内部函数访问外部函数的局部变量
        return sum
    }
}

func main() {
    // 创建一个闭包函数，该函数可以累加传入的参数
    myAdder := adder()

    // 调用闭包函数，实现累加
    fmt.Println(myAdder(1)) // 输出结果：1
    fmt.Println(myAdder(2)) // 输出结果：3
    fmt.Println(myAdder(3)) // 输出结果：6
}

在上面的例子中，我们定义了一个外部函数adder，它返回了一个闭包函数。闭包函数中引用了外部函数的局部变量sum，并可以持续地累加传入的参数。每次调用myAdder函数，都会保留之前的sum值，并在原来的基础上继续累加。这就是闭包的特性，使得局部变量sum的生命周期得到了延长，并在多次调用中保持了状态。

闭包在Go语言中是一种非常有用且强大的特性，可以用于简化代码、实现高阶函数和实现回调机制。但在使用闭包时，要注意不要滥用闭包，避免造成资源泄漏或不必要的性能损失。