当前位置： 首页 > article >正文

【go语言】函数

article 2025/1/30 8:22:13

一、什么是函数

函数是入门简单精通难，函数是什么？？？

  • 函数就是一段代码的集合
  • go 语言中至少有一个 main 函数
  • 函数需要有一个名字，独立定义的情况下，见名知意
  • 函数可能需要有一个结果，也可能没有

函数和方法完全是不一样的东西，面向对象里面才有方法

二、函数的具体定义

       在 go 语言中，函数是代码块的集合，用于执行特定任务或者计算。函数接受输入（成为参数），执行操作并返回输出（称为返回值）。go 语言中的函数定义非常简单且灵活。

2.1 函数的定义

在 go 语言中，函数通过 func 关键字定义。函数定义的基本格式如下：

func FunctionName(parameterList) returnType {
    // Function body
}
  • func：用于声明函数。
  • FunctionName：函数的名字，通常首字母大写表示公开（exported）函数，首字母小写表示私有（unexported）函数。
  • parameterList：参数列表（可选），参数使用 name type 的格式。多个参数之间用逗号分隔。
  • returnType：返回值类型（可选）。如果函数没有返回值，则省略。

2.2 没有参数和返回值的函数

func SayHello() {
    fmt.Println("Hello, World!")
}

在这个例子中：

  • SayHello 是函数的名称。
  • 函数没有任何参数。
  • 函数没有返回值，只是打印了一句 "Hello, World!"。

2.3 带有参数的函数

func Add(a int, b int) int {
    return a + b
}
  • a 和 b 是函数的参数，它们都是 int 类型。
  • 函数返回一个 int 类型的值，表示两个整数的和。

2.4 多个参数类型相同的函数

如果函数的多个参数类型相同，可以简化参数定义，只指定类型一次：

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

在这个例子中，a 和 b 都是 int 类型，Go 会自动推断它们的类型。

2.5 带有多个返回值的函数

       Go 语言支持多个返回值的函数。你可以定义一个函数返回多个值，通常用来返回计算结果和错误等信息：

func Divide(a, b int) (int, error) {
    if b == 0 {
        return 0, fmt.Errorf("division by zero")
    }
    return a / b, nil
}

在这个例子中：

  • Divide 函数接收两个 int 类型的参数 a 和 b。
  • 返回两个值，第一个是商（int 类型），第二个是错误（error 类型），如果除数 b 为 0，则返回错误。

2.6 没有返回值的函数

某些函数只执行操作，没有返回值，常用于执行副作用（如修改变量或打印输出）：

func PrintMessage(message string) {
    fmt.Println(message)
}

在这个例子中：

  • PrintMessage 函数接收一个 string 类型的参数，并打印它。
  • 该函数没有返回值。

2.7 函数的参数和返回值

  • 参数：函数接受的输入数据，可以有多个，也可以没有。
  • 返回值：函数的输出，可以有多个返回值，也可以没有。

2.8 函数作为值

       Go 语言允许将函数作为值传递，这意味着函数可以作为参数传递给其他函数，或者作为返回值返回。

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

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

func main() {
    result := ApplyOperation(3, 4, Add)  // 将 Add 函数作为参数传递
    fmt.Println(result)  // 输出 7
}

2.9 匿名函数（闭包）

Go 也支持匿名函数（没有名字的函数），它们通常用于作为参数传递，或者在函数内部定义。

func main() {
    add := func(a, b int) int {
        return a + b
    }
    fmt.Println(add(2, 3))  // 输出 5
}

这个 add 函数就是一个匿名函数，它定义在 main 函数内部。 

2.10 递归函数

       递归是函数调用自身的过程。在 Go 中，递归函数的使用与其他语言相似。以下是一个简单的递归函数示例，用于计算阶乘：

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

三、函数的可变参数

       在 go 语言中，函数支持可变参数。这意味着你可以在函数调用时传入任意数量的参数，而不必预先指定参数的数量。可变参数允许函数接受零个或者多个相同类型的参数。

3.1 可变参数的语法

定义可变参数时，使用 ... 语法，表示一个参数可以接受多个值。具体格式如下：

func FunctionName(paramType ...Type) {
    // Function body
}
  • paramType 是参数的名字。
  • Type 是参数的类型。
  • ... 表示该参数是可变的，可以接受任意数量的 Type 类型的参数。 

3.2 使用可变参数

下面是一个简单的例子，展示如何使用可变参数来计算多个数的和：

package main

import "fmt"

// Sum 函数接受一个可变参数 numbers，并计算它们的和
func Sum(numbers ...int) int {
    total := 0
    for _, num := range numbers {
        total += num
    }
    return total
}

func main() {
    fmt.Println(Sum(1, 2, 3))          // 输出 6
    fmt.Println(Sum(10, 20, 30, 40))   // 输出 100
    fmt.Println(Sum())                 // 输出 0
}
  • Sum 函数的参数 numbers ...int 允许它接收任意数量的整数作为输入。
  • 在 main 函数中，我们可以调用 Sum 并传入任意数量的参数。

3.3 可变参数与切片

       可变参数的类型实际上是一个切片（slice）。在函数内部，它就像一个普通的切片一样，你可以对它进行切片操作。

package main

import "fmt"

func PrintArgs(args ...string) {
    fmt.Println(args)  // 打印整个切片
}

func main() {
    PrintArgs("apple", "banana", "cherry")  // 输出: [apple banana cherry]
}

       在上面的代码中，args 变量是一个 []string 类型的切片，因此你可以像操作切片一样操作它。 

3.4 可变参数与其他参数

       如果函数同时有可变参数和常规参数，那么可变参数必须是函数参数列表中的最后一个参数。

package main

import "fmt"

// PrintDetails 函数接受一个名字参数和可变参数 info
func PrintDetails(name string, info ...string) {
    fmt.Println("Name:", name)
    fmt.Println("Info:", info)
}

func main() {
    PrintDetails("Alice", "25", "Engineer", "New York")  // 输出: Name: Alice Info: [25 Engineer New York]
    PrintDetails("Bob")  // 输出: Name: Bob Info: []
}
  • 在这个例子中，PrintDetails 函数的第一个参数是 name，第二个是可变参数 info。你可以传递任意数量的字符串作为 info 参数 

3.5 可变参数传递切片

如果你已经有了一个切片，并希望将其作为可变参数传递给函数，可以使用 ... 来解构切片。

package main

import "fmt"

// Sum 函数计算任意数量的整数的和
func Sum(numbers ...int) int {
    total := 0
    for _, num := range numbers {
        total += num
    }
    return total
}

func main() {
    nums := []int{1, 2, 3, 4}
    result := Sum(nums...)  // 使用 '...' 解构切片
    fmt.Println(result)      // 输出 10
}

3.6 可变参数的限制

  • 你不能在函数的参数列表中同时出现多个可变参数。
  • 可变参数必须是参数列表中的最后一个参数。
  • 可变参数允许函数接收零个或多个同类型的参数，提供了更大的灵活性。
  • 可变参数在函数内部实际上是一个切片，你可以像操作切片一样操作它。
  • 如果一个函数同时有常规参数和可变参数，可变参数必须位于最后。

 通过使用可变参数，Go 语言提供了一种简单且强大的方式来处理不确定数量的输入。

3.7 参数的传递细节

       在 Go 语言中，函数的参数传递遵循值传递的规则。具体来说，参数在传递给函数时，都会创建一份副本，不会直接传递原始变量。这意味着在函数内部对参数的修改不会影响外部的变量。Go 的参数传递机制可以分为以下几种情况：

3.7.1 值传递

       Go 中默认是值传递。当你传递一个值作为参数时，函数会接收到该值的副本。在函数内部对该副本的修改不会影响原始数据。

package main

import "fmt"

func modify(x int) {
    x = 10
    fmt.Println("Inside modify:", x)  // 修改副本，不会影响原始变量
}

func main() {
    num := 5
    fmt.Println("Before modify:", num)
    modify(num)
    fmt.Println("After modify:", num)  // 原始变量 num 不受影响
}

3.7.2 引用传递

       虽然 Go 的参数传递是值传递，但通过传递指针（即引用类型）可以模拟引用传递。这意味着函数接收到的是原始数据的地址（指针），在函数内部对数据的修改会直接影响外部的变量。

package main

import "fmt"

func modify(x *int) {
    *x = 10  // 修改原始变量
    fmt.Println("Inside modify:", *x)
}

func main() {
    num := 5
    fmt.Println("Before modify:", num)
    modify(&num)  // 传递 num 的指针
    fmt.Println("After modify:", num)  // 原始变量 num 被修改
}

但是，这里有一个很简单的例子需要进行观察：

func add(a, b *int) {
    a, b = b, a
}

3.7.3 数组和切片的传递

在 Go 中，数组是按值传递的，而切片则是按引用传递的。具体来说：

  • 数组：当传递数组时，会复制整个数组，因此在函数内部对数组的修改不会影响原始数组。
  • 切片：切片包含指向底层数组的指针，当传递切片时，传递的是指向底层数组的指针。因此，函数内部对切片的修改会影响外部的切片。

3.7.4 结构体的传递

  • 结构体的值传递：结构体按值传递，函数接收到的是结构体的副本。
  • 结构体的指针传递：结构体的指针按引用传递，函数接收到的是原始结构体的地址，可以直接修改原始结构体。
  • 值传递：函数接收的是参数的副本，修改副本不会影响原始数据。
  • 指针传递：函数接收的是原始数据的地址，修改数据会直接影响原始变量。
  • 数组：按值传递，函数内部修改副本不会影响原始数组。
  • 切片：按引用传递，修改切片会直接影响原始切片。
  • 结构体：可以按值或指针传递，按值传递时修改副本，按指针传递时修改原始结构体。

四、函数的闭包特性

       在 Go 语言中，闭包（Closure）是指一个函数能够“记住”并访问定义时的作用域中的变量，即使这个函数在定义时的作用域已经结束。闭包允许一个函数携带它所引用的变量，从而可以在外部函数调用时继续使用这些变量。闭包是 Go 语言中一个非常强大且常用的特性，尤其在处理回调函数和高阶函数时非常有用。

4.1 闭包的基本概念

       闭包是由函数和他的外部环境（自由变量）组合而成的。换句话说，闭包不仅仅是一个函数，他还携带者该函数定义时的变量的引用。因此，闭包可以“记住”外部函数中的变量，即使外部函数已经返回。

4.2 go 语言中闭包的特性

  1. 可以访问外部函数的变量：闭包可以访问和修改外部函数的变量，即使外部函数已经执行完毕。
  2. 可以动态改变外部变量的值：闭包能够改变外部函数中的局部变量。
  3. 闭包可以作为返回值：函数可以返回闭包，这使得我们能够在外部创建函数并使用这些函数。

简单闭包

package main

import "fmt"

func outer() func() {
    // 外部函数的局部变量
    x := 10

    // 返回一个闭包
    return func() {
        fmt.Println(x)  // 闭包可以访问外部函数的变量 x
    }
}

func main() {
    // 调用 outer 函数并获取返回的闭包
    closure := outer()

    // 调用闭包
    closure()  // 输出: 10
}

       在上面的代码中，outer 函数返回了一个闭包，该闭包访问了 outer 函数的局部变量 x。即使 outer 函数已经执行完毕，闭包仍然可以访问 x 的值。

修改外部变量的闭包

闭包不仅可以访问外部变量，还可以修改外部变量的值：

package main

import "fmt"

func outer() func() int {
    x := 10
    // 返回闭包，闭包内部会修改 x
    return func() int {
        x++
        return x
    }
}

func main() {
    closure := outer()
    fmt.Println(closure())  // 输出: 11
    fmt.Println(closure())  // 输出: 12
}

       在上面的例子中，closure 每次被调用时，都会修改并返回 x 的值。这是因为 closure 是一个闭包，它“记住”了 x 的值，并可以修改它。

4.3 闭包作为函数参数

package main

import "fmt"

// 定义一个接受函数作为参数的函数
func applyOperation(x int, operation func(int) int) int {
    return operation(x)
}

func main() {
    // 定义一个闭包，作为 applyOperation 函数的参数
    add5 := func(x int) int {
        return x + 5
    }

    result := applyOperation(10, add5)
    fmt.Println(result)  // 输出: 15
}

4.4 闭包与匿名函数

       匿名函数和闭包的关系在于：匿名函数本身可以是一个闭包。闭包的定义是：一个函数能够访问并捕获其外部作用域的变量，匿名函数的特性是它没有名字，它也可以捕获外部作用域的变量。因此，匿名函数和闭包在 Go 中是高度相关的。

       匿名函数在 Go 语言中非常常见，它本身也是闭包的一种形式。匿名函数定义时不需要指定名字，但它可以作为闭包捕获外部变量。

package main

import "fmt"

func main() {
    // 匿名函数作为闭包
    x := 5
    closure := func() {
        fmt.Println(x)  // 闭包访问外部变量 x
    }

    closure()  // 输出: 5
}

4.5 闭包的声明周期

       闭包的生命周期比外部函数的生命周期要长。当你将闭包返回并在外部使用时，闭包可以继续访问外部函数的变量。也就是说，闭包的变量会“延续”到闭包的生命周期，而不是外部函数的生命周期。

package main

import "fmt"

func outer() func() int {
    x := 10
    return func() int {
        x++
        return x
    }
}

func main() {
    closure1 := outer()
    closure2 := outer()

    fmt.Println(closure1())  // 输出: 11
    fmt.Println(closure1())  // 输出: 12
    fmt.Println(closure2())  // 输出: 11
    fmt.Println(closure2())  // 输出: 12
}

五、defer 延迟函数

package main

import "fmt"

// defer
func main() {
   f("1")
   fmt.Println("2")
   defer f("3")
   fmt.Println("4")
}

func f(s string) {
   fmt.Println(s)
}

defer函数或者方法：一个函数或方法的执行被延迟了

  • 你可以在函数中添加多个defer语句，当函数执行到最后时，这些defer语句会按照逆序执行，最后该函数返回，特别是当你在进行一些打开资源的操作时i/o 流，遇到错误需要提前返回，在返回前你需要关闭相应的资源，不然很容易造成资源泄露等问题
  • 如果有很多调用 defer，那么 defer 是采用 后进先出（栈） 模式。

六、go 的 error 设计理念

       go 语言中的 error 类型设计理念是其简洁性和明确性的重要体现之一。与许多其他编程语言不同，go 不使用异常机制（比如 try / catch）来处理错误，而是通过现实返回错误值来处理。这种设计理念使得代码更加清晰且易于理解，同时也让错误处理变得更加直接和显式。

以下是 go 语言中 error 设计理念的几个核心点：

6.1 错误是值

Go 语言中的错误是一个普通的类型，具体是 error 类型。它是一个接口类型，定义如下：

type error interface {
    Error() string
}

  error 接口有一个方法 Error()，返回一个描述错误的字符串。这使得错误本质上是一个可以传递和操作的值。任何类型实现了 Error() 方法的都可以被视作一个错误。

6.2 显式错误处理

       Go 强烈鼓励显式地处理错误，而不是像其他语言那样隐式地捕获或忽略错误。这种设计使得错误处理不容易被遗漏，增强了代码的可靠性。

       在 Go 中，函数通常会返回两个值：一个是正常的返回值，另一个是 error 类型的错误值。调用方必须显式地检查这个错误值，以决定是否继续执行。

package main

import (
    "fmt"
    "errors"
)

func divide(a, b int) (int, error) {
    if b == 0 {
        return 0, errors.New("division by zero")
    }
    return a / b, nil
}

func main() {
    result, err := divide(10, 0)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    fmt.Println("Result:", result)
}

6.3 返回 nil 表示没有错误

       Go 中的错误值如果没有发生错误，通常返回 nil，这意味着没有错误发生。因此，检查错误时，常常会看到 err != nil 来判断是否有错误发生。

func someFunction() error {
    // 正常情况，返回 nil 表示没有错误
    return nil
}

七、recover 和 panic

在 go 语言中，recover 和 panic 是用于处理异常和错误的一对机制。

7.1 panic（恐慌）

       panic 用于在程序中遇到不可恢复的错误时主动抛出异常。调用 panic 会导致程序终止执行，当前函数的执行将会被停止，并且会沿着调用栈往上返回，直到遇到 recover 或者程序终止。

package main

import "fmt"

func causePanic() {
    panic("Something went wrong!")
}

func main() {
    causePanic()
    fmt.Println("This line will not be executed.")
}

在这个例子中，panic 会立即停止程序的执行，fmt.Println 将不会被执行。 

7.2 recover（恢复）

       recover 只能在 defer 语句中使用，他用于捕获 panic 产生的异常。通常，recover 用于恢复程序的正常执行，防止程序崩溃。当程序进入 panic 状态时，如果当前有一个被 defer 声明的函数调用 recover，则 recover 会捕获这个 panic，并阻止程序退出。

       recover 会返回 panic 传入的参数（通常是错误信息），如果没有发生 panic，recover 返回 nil。

package main

import "fmt"

func safeDivide(a, b int) int {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("Recovered from panic:", r)
        }
    }()
    
    if b == 0 {
        panic("division by zero")
    }
    return a / b
}

func main() {
    fmt.Println(safeDivide(10, 2))  // 正常执行
    fmt.Println(safeDivide(10, 0))  // 会触发 panic，并被 recover 捕获
}

       在这个例子中，当 safeDivide(10, 0) 被调用时，由于 panic 被触发，defer 中的匿名函数会执行 recover，从而避免程序崩溃，并打印出错误信息。

  • panic 用于主动触发异常，通常用于不可恢复的错误。
  • recover 用于捕获 panic，并防止程序崩溃，通常在 defer 语句中使用。

  panic 和 recover 机制一般用于错误处理的最后一道防线，正常的错误处理应该通过返回错误来进行，而 panic/recover 应该谨慎使用。

八、函数的数据类型

  • func （xxxx,xxx） xxx,xxxx
  • 函数也是一种数据类型，可以定义函数类型的变量
package main

import "fmt"

// 函数是什么（数据类型）
func main() {
	a := 10.01
	fmt.Printf("%T\n", a) // 查看变量的类型
	b := [4]int{1, 2, 3, 4}
	fmt.Printf("%T\n", b) // 查看变量的类型
	c := true
	fmt.Printf("%T\n", c) // 查看变量的类型

	// 函数的类型
	func1()                   // 带了括号是函数的调用
	fmt.Printf("%T\n", func1) // 查看变量的类型 func()
	fmt.Printf("%T\n", func2) // 查看变量的类型 func(int) int
	// func(int, int) (int, int)
	// func(int, int, ...string) (int, int)
	//var fun3 func(int, int, ...string) (int, int)
	fun3 := func2
	r1, r2 := fun3(1, 2, "111")
	fmt.Println(r1, r2)
	// 函数在Go语言中本身也是一个数据类型，加了（） 是调用函数，不加（）, 函数也是一个变量，可以赋值给别人。

	// 函数的类型就等于该函数创建的类型，他也可以赋值给
}

// 无参无返回值的函数
func func1() {

}

// 有参有返回值的函数
func func2(a, b int, c ...string) (int, int) {
	return 0, 0
}

九、函数的本质

       函数的本质是将一段代码封装成一个可重复调用的独立单元，他接受输入（参数）并产生输出（返回值）。通过函数，我们能够实现代码的复用、模块化和抽象，简化程序的设计和维护。

具体来说，函数的本质可以从以下几个方面来理解：

9.1 封装性

函数将一组操作封装在一起，使得代码的实现细节与外部调用者分离。调用者之关心如何实现函数，而不需要关心函数内部的实现细节。

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

       在上面的例子中，add 函数将两个整数相加，调用者只需知道如何调用这个函数，而不需要知道加法的具体实现。

9.2 参数和返回值

       函数接受输入参数，并基于这些输入执行某些操作后返回结果。参数允许函数根据不同的输入产生不同的输出，返回值则提供了函数执行后的结果。

func multiply(x int, y int) int {
    return x * y
}

9.3 可重用性和抽象

       通过函数，代码可以在不同的地方被调用，而不需要重复编写相同的逻辑。这使得程序更易于维护和扩展。

func greet(name string) {
    fmt.Println("Hello, " + name)
}

greet("Alice")
greet("Bob")

9.4 函数作为一等公民

       在许多现代编程于语言中，函数不仅是可以调用的代码块，还可以像其他数据类型一样赋值给变量、作为参数传递、作为返回值返回。也就是说，函数可以作为数据来处理，增强了语言的灵活性和表达力。

func apply(f func(int, int) int, x int, y int) int {
    return f(x, y)
}

result := apply(multiply, 3, 4) // 传递 multiply 函数
fmt.Println(result) // 输出 12

9.5 递归

       函数可以调用自身，这种特性称为递归。递归是一个强大的概念，常用于解决分治问题和数学问题。

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

9.6 作用域和生命周期

       函数中的变量通常在函数的作用域中内有效，一旦函数调用结束，这些变量就会销毁。这个特性有助于避免外部变量的干扰，使得函数的执行更加独立和可预测。

func counter() func() int {
    count := 0
    return func() int {
        count++
        return count
    }
}

increment := counter()
fmt.Println(increment()) // 1
fmt.Println(increment()) // 2

在这个例子中，counter 函数返回一个闭包，这个闭包可以通过 count 变量维护其状态。

函数的本质是：

  • 封装代码：将可重复使用的代码块封装成一个单元，提供简洁的接口。
  • 参数和返回值：通过参数接受输入，通过返回值输出结果。
  • 可重用性和抽象：避免重复代码，通过抽象提高程序的可维护性和可扩展性。
  • 一等公民：函数可以作为数据类型处理，可以作为参数传递或返回。
  • 递归：函数可以调用自己，用于解决特定类型的问题。
  • 作用域和生命周期：每次函数调用时都会创建新的作用域，函数内部的变量在调用结束后销毁。

十、回调函数

       回调函数是一种通过函数指针或者函数作为参数传递的编程技术。简单来说，回调函数是一个由其他函数作为参数传递并在特定条件下执行的函数。

10.1 回调函数的工作原理

       回调函数的基本思想是：我们定义一个函数（回调函数），然后将它传递给另一个函数，当某个事件或条件发生时，后者函数会调用这个回调函数。回调函数允许我们在特定时机自定义程序的行为，而不必修改核心逻辑。

10.2 回调函数的使用场景

回调函数通常用在以下场景中：

  1. 异步操作：例如，处理事件或完成某个任务后执行某个操作（比如网络请求完成后的操作）。
  2. 事件监听：例如，在图形用户界面中，用户点击按钮时触发回调函数。
  3. 函数式编程：在函数式编程中，回调函数用于处理数据流和函数组合。

10.3 回调函数的例子

在 Go 语言中的回调函数

Go 语言允许将函数作为参数传递，可以实现回调的功能。

package main

import "fmt"

// 定义一个回调函数类型
type Callback func(int, int) int

// 这个函数接受一个回调函数作为参数
func operate(a int, b int, callback Callback) int {
    return callback(a, b)
}

// 定义两个不同的回调函数
func add(x int, y int) int {
    return x + y
}

func multiply(x int, y int) int {
    return x * y
}

func main() {
    // 调用 operate 函数，传入不同的回调函数
    result1 := operate(5, 3, add)      // 输出 8
    result2 := operate(5, 3, multiply) // 输出 15

    fmt.Println("Add result:", result1)
    fmt.Println("Multiply result:", result2)
}

在这个例子中：

  • operate 函数接受一个回调函数 callback 作为参数。
  • 然后，operate 会调用这个回调函数（add 或 multiply）来处理两个参数 a 和 b。
  • 根据传入的回调函数，执行不同的操作（加法或乘法）。
异步操作中的回调函数（模拟）

回调函数通常用于异步操作。在一些编程环境中，你可能会看到它在处理异步事件时的使用方式。

package main

import (
    "fmt"
    "time"
)

// 模拟一个异步任务的回调函数
func doAsyncTask(callback func(string)) {
    go func() {
        time.Sleep(2 * time.Second) // 模拟耗时操作
        callback("Task Completed!")
    }()
}

func main() {
    // 调用异步任务并传入回调函数
    doAsyncTask(func(result string) {
        fmt.Println(result) // 输出 "Task Completed!"
    })

    // 主程序继续执行
    fmt.Println("Waiting for the task to complete...")
    time.Sleep(3 * time.Second) // 等待异步操作完成
}

在这个例子中：

  • doAsyncTask 函数接受一个回调函数作为参数，并通过 go 关键字异步执行一些任务（在这里是模拟的耗时操作）。
  • 当任务完成后，回调函数会被调用并输出结果。
  • main 函数并不会等待异步操作，而是继续执行后面的代码，直到异步任务完成后，回调函数才被调用。

       回调函数允许程序在某些时机执行特定的代码，通常用于事件驱动、异步操作或函数式编程中。它使得程序更加灵活，能够让开发者根据需求定制代码的行为。在 Go 语言中，通过将函数作为参数传递，可以轻松实现回调函数的功能。


http://www.kler.cn/a/524436.html

相关文章：

  • PySide(PyQT)进行SQLite数据库编辑和前端展示的基本操作
  • （Java版本）基于JAVA的网络通讯系统设计与实现-毕业设计
  • 联想Y7000+RTX4060+i7+Ubuntu22.04运行DeepSeek开源多模态大模型Janus-Pro-1B+本地部署
  • 支持selenium的chrome driver更新到132.0.6834.110
  • 分布式版本控制系统：Git
  • 电路研究9.2.3——合宙Air780EP中FTP——FTPGET 命令使用方法研究
  • springboot基于SpringBoot的养老院管理系统设计与实现
  • RDK X5运行DeepSeek-R1-Distill-Qwen-1.5B，体验长思维链的语言大模型！
  • 芯片AI深度实战：基础篇之Ollama
  • GAEA 社区：从用户到共同创造者
  • 线程概念、操作
  • Python NumPy（6）：修改数组形状、翻转数组、修改数组维度
  • MySQL查询优化（三）：深度解读 MySQL客户端和服务端协议
  • 网站如何正式上线（运维详解）
  • 解决 pip install 出现 error: subprocess-exited-with-error 错误的方法
  • 小黑日常积累:学习了CROSS APPLY字段，将sqlserver中字段通过分隔符拆分并统计
  • “爱”之浅谈（一）
  • 混合专家模型MoE的全面详解
  • MybatisX插件快速创建项目
  • [C语言日寄] ＜stdio.h＞ 头文件功能介绍
  • Go学习：字符、字符串需注意的点
  • MotionLCM 部署笔记
  • 基于最近邻数据进行分类
  • 蓝牙技术在物联网中的应用有哪些
  • xclode版本
  • AI大模型开发原理篇-1：语言模型雏形之N-Gram模型