【Go-4】函数

c无序2025-05-24 11:54

函数

函数是编程中的基本构建块，用于封装可重用的代码逻辑。Go语言中的函数功能强大，支持多种特性，如多返回值、可变参数、匿名函数、闭包以及将函数作为值和类型传递。理解和掌握函数的使用对于编写高效、可维护的Go程序至关重要。本章将详细介绍Go语言中的函数，包括函数的定义与调用、参数和返回值、可变参数函数、匿名函数与闭包，以及函数作为值和类型的应用。

4.1 函数定义与调用

函数的基本定义

在Go语言中，函数使用func关键字定义。函数可以包含参数和返回值，也可以没有。

基本语法：

go 复制代码 
func 函数名(参数列表) (返回值列表) {
    // 函数体
}
  • func: 函数定义的关键字。
  • 函数名: 函数的名称，遵循标识符命名规则。
  • 参数列表: 函数接受的参数，可以有多个，每个参数需要指定类型。
  • 返回值列表: 函数返回的值，可以有多个，需指定类型。
  • 函数体: 包含函数执行的代码。

示例：

go 复制代码 
package main

import "fmt"

// 定义一个简单的函数，不接受参数，也不返回值
func sayHello() {
    fmt.Println("Hello, Go!")
}

func main() {
    sayHello() // 调用函数
}

输出：

复制代码 
Hello, Go!
带参数的函数

函数可以接受多个参数，每个参数需要指定类型。参数之间用逗号分隔。

示例：

go 复制代码 
package main

import "fmt"

// 定义一个函数，接受两个整数参数并打印它们的和
func add(a int, b int) {
    sum := a + b
    fmt.Println("Sum:", sum)
}

func main() {
    add(5, 3) // 调用函数，传递参数5和3
}

输出：

复制代码 
Sum: 8

参数类型简写：

当连续的参数具有相同的类型时，可以简化参数类型的声明。

示例：

go 复制代码 
package main

import "fmt"

// 简化参数类型声明
func multiply(a, b int) {
    product := a * b
    fmt.Println("Product:", product)
}

func main() {
    multiply(4, 6) // 调用函数，传递参数4和6
}

输出：

复制代码 
Product: 24
带返回值的函数

函数可以返回一个或多个值。返回值需要在函数定义中指定。

示例：

go 复制代码 
package main

import "fmt"

// 定义一个函数，接受两个整数参数并返回它们的和
func add(a int, b int) int {
    return a + b
}

func main() {
    sum := add(10, 15) // 调用函数，并接收返回值
    fmt.Println("Sum:", sum)
}

输出：

复制代码 
Sum: 25
多返回值函数

Go语言支持函数返回多个值，这在错误处理和复杂数据返回时非常有用。

示例：

go 复制代码 
package main

import (
    "fmt"
    "math"
)

// 定义一个函数，返回两个值：平方根和平方
func calculate(x float64) (float64, float64) {
    sqrt := math.Sqrt(x)
    square := x * x
    return sqrt, square
}

func main() {
    number := 16.0
    sqrt, square := calculate(number) // 接收多个返回值
    fmt.Printf("Number: %.2f, Square Root: %.2f, Square: %.2f\n", number, sqrt, square)
}

输出：

复制代码 
Number: 16.00, Square Root: 4.00, Square: 256.00
命名返回值

函数的返回值可以命名，这样在函数体内可以直接使用这些名字，并且可以使用return语句直接返回。

示例：

go 复制代码 
package main

import "fmt"

// 定义一个函数，返回两个命名的返回值
func divide(a, b float64) (quotient float64, remainder float64) {
    quotient = a / b
    remainder = math.Mod(a, b)
    return // 自动返回命名的返回值
}

func main() {
    q, r := divide(10.5, 3.2)
    fmt.Printf("Quotient: %.2f, Remainder: %.2f\n", q, r)
}

输出：

复制代码 
Quotient: 3.28, Remainder: 0.90

4.2 函数参数和返回值

函数参数和返回值是函数与外界交互的主要方式。Go语言在参数传递和返回值处理上有其独特的特性。

参数传递方式

Go语言中的参数传递是按值传递，这意味着函数接收到的是参数的副本，对副本的修改不会影响原始变量。

示例：

go 复制代码 
package main

import "fmt"

// 定义一个函数，尝试修改参数的值
func modifyValue(x int) {
    x = 100
    fmt.Println("Inside modifyValue:", x)
}

func main() {
    a := 50
    modifyValue(a)
    fmt.Println("After modifyValue:", a) // a的值不会被修改
}

输出：

复制代码 
Inside modifyValue: 100
After modifyValue: 50
使用指针传递参数

为了在函数内部修改外部变量的值，可以使用指针传递参数。指针传递允许函数直接访问和修改变量的内存地址。

示例：

go 复制代码 
package main

import "fmt"

// 定义一个函数，使用指针修改参数的值
func modifyPointer(x *int) {
    *x = 100
    fmt.Println("Inside modifyPointer:", *x)
}

func main() {
    a := 50
    fmt.Println("Before modifyPointer:", a)
    modifyPointer(&a) // 传递变量a的地址
    fmt.Println("After modifyPointer:", a) // a的值被修改
}

输出：

复制代码 
Before modifyPointer: 50
Inside modifyPointer: 100
After modifyPointer: 100
多参数函数

Go语言支持多个参数的函数，可以组合使用不同类型的参数。

示例：

go 复制代码 
package main

import "fmt"

// 定义一个函数，接受多个不同类型的参数
func printDetails(name string, age int, height float64) {
    fmt.Printf("Name: %s, Age: %d, Height: %.2f\n", name, age, height)
}

func main() {
    printDetails("Alice", 30, 5.6)
    printDetails("Bob", 25, 5.9)
}

输出：

复制代码 
Name: Alice, Age: 30, Height: 5.60
Name: Bob, Age: 25, Height: 5.90
可选参数

Go语言不直接支持可选参数，但可以通过参数的组合和使用指针来模拟实现。

示例：

go 复制代码 
package main

import "fmt"

// 定义一个函数，使用指针模拟可选参数
func greet(name string, title *string) {
    if title != nil {
        fmt.Printf("Hello, %s %s!\n", *title, name)
    } else {
        fmt.Printf("Hello, %s!\n", name)
    }
}

func main() {
    var title string = "Dr."
    greet("Alice", &title) // 使用标题
    greet("Bob", nil)      // 不使用标题
}

输出：

复制代码 
Hello, Dr. Alice!
Hello, Bob!

4.3 可变参数函数

可变参数函数允许函数接受任意数量的参数。这在处理不确定数量输入时非常有用。Go语言通过在参数类型前加...来定义可变参数。

定义可变参数函数

基本语法：

go 复制代码 
func 函数名(参数类型, ...参数类型) 返回值类型 {
    // 函数体
}

示例：

go 复制代码 
package main

import "fmt"

// 定义一个函数，接受可变数量的整数参数并求和
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(10, 20, 30, 40)) // 输出: 100
    fmt.Println(sum())              // 输出: 0
}

输出：

复制代码 
6
100
0
使用可变参数的其他示例

示例1：打印多个字符串

go 复制代码 
package main

import "fmt"

// 定义一个函数，接受可变数量的字符串参数并打印
func printStrings(strs ...string) {
    for _, s := range strs {
        fmt.Println(s)
    }
}

func main() {
    printStrings("Go", "is", "fun")
    printStrings("Hello", "World")
    printStrings()
}

输出：

复制代码 
Go
is
fun
Hello
World

示例2：计算多个浮点数的平均值

go 复制代码 
package main

import "fmt"

// 定义一个函数，接受可变数量的浮点数参数并计算平均值
func average(nums ...float64) float64 {
    if len(nums) == 0 {
        return 0
    }
    total := 0.0
    for _, num := range nums {
        total += num
    }
    return total / float64(len(nums))
}

func main() {
    fmt.Printf("Average: %.2f\n", average(1.5, 2.5, 3.5))       // 输出: Average: 2.50
    fmt.Printf("Average: %.2f\n", average(10.0, 20.0))         // 输出: Average: 15.00
    fmt.Printf("Average: %.2f\n", average())                  // 输出: Average: 0.00
}

输出：

复制代码 
Average: 2.50
Average: 15.00
Average: 0.00
将切片传递给可变参数函数

如果已经有一个切片，可以使用...操作符将切片元素作为可变参数传递给函数。

示例：

go 复制代码 
package main

import "fmt"

// 定义一个函数，接受可变数量的整数参数并求和
func sum(nums ...int) int {
    total := 0
    for _, num := range nums {
        total += num
    }
    return total
}

func main() {
    numbers := []int{4, 5, 6}
    total := sum(numbers...) // 使用...将切片传递为可变参数
    fmt.Println("Total:", total) // 输出: Total: 15
}

输出：

复制代码 
Total: 15

4.4 匿名函数与闭包

匿名函数

匿名函数是没有名称的函数，可以在定义时直接调用，或赋值给变量以便后续使用。匿名函数在需要临时使用函数逻辑时非常有用。

示例1：立即调用匿名函数

go 复制代码 
package main

import "fmt"

func main() {
    // 定义并立即调用匿名函数
    func() {
        fmt.Println("This is an anonymous function!")
    }()

    // 带参数的匿名函数
    func(a, b int) {
        fmt.Printf("Sum: %d\n", a+b)
    }(3, 4)
}

输出：

复制代码 
This is an anonymous function!
Sum: 7

示例2：将匿名函数赋值给变量

go 复制代码 
package main

import "fmt"

func main() {
    // 将匿名函数赋值给变量
    greet := func(name string) {
        fmt.Printf("Hello, %s!\n", name)
    }

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

输出：

复制代码 
Hello, Alice!
Hello, Bob!
闭包

闭包是指一个函数可以访问其外部作用域中的变量，即使外部函数已经返回。闭包允许函数"记住"并操作其定义时的环境变量。

示例1：简单闭包

go 复制代码 
package main

import "fmt"

// 定义一个生成器函数，返回一个闭包
func generator() func() int {
    count := 0
    return func() int {
        count++
        return count
    }
}

func main() {
    next := generator()

    fmt.Println(next()) // 输出: 1
    fmt.Println(next()) // 输出: 2
    fmt.Println(next()) // 输出: 3

    another := generator()
    fmt.Println(another()) // 输出: 1
}

输出：

复制代码 
1
2
3
1

解释：

  • generator函数返回一个匿名函数，该匿名函数访问并修改外部变量count。
  • 每次调用next()时，count都会递增。
  • another是另一个闭包实例，拥有独立的count变量。

示例2：闭包与参数

go 复制代码 
package main

import "fmt"

// 定义一个函数，返回一个闭包，该闭包会将输入乘以指定的因子
func multiplier(factor int) func(int) int {
    return func(x int) int {
        return x * factor
    }
}

func main() {
    double := multiplier(2)
    triple := multiplier(3)

    fmt.Println("Double 5:", double(5)) // 输出: Double 5: 10
    fmt.Println("Triple 5:", triple(5)) // 输出: Triple 5: 15
}

输出：

复制代码 
Double 5: 10
Triple 5: 15

解释：

  • multiplier函数接受一个factor参数，并返回一个闭包。
  • 该闭包接受一个整数x，并返回x乘以factor的结果。
  • double和triple是两个不同的闭包实例，分别将输入数值乘以2和3。
闭包的应用场景
  • 延迟执行：将某些操作延迟到特定条件下执行。
  • 数据封装：封装数据，保护数据不被外部直接修改。
  • 回调函数：作为回调函数传递给其他函数，以实现灵活的功能扩展。

示例：延迟执行

go 复制代码 
package main

import "fmt"

// 定义一个函数，接受一个函数作为参数
func performOperation(operation func()) {
    fmt.Println("准备执行操作...")
    operation()
    fmt.Println("操作执行完毕。")
}

func main() {
    performOperation(func() {
        fmt.Println("这是一个延迟执行的匿名函数。")
    })
}

输出：

复制代码 
准备执行操作...
这是一个延迟执行的匿名函数。
操作执行完毕。

4.5 函数作为值和类型

在Go语言中，函数可以作为值来传递和使用。这意味着函数可以被赋值给变量、作为参数传递给其他函数，甚至作为返回值返回。这种特性使得Go语言在函数式编程方面具有很大的灵活性。

将函数赋值给变量

函数可以被赋值给变量，从而实现对函数的引用和调用。

示例：

go 复制代码 
package main

import "fmt"

// 定义一个简单的函数
func sayHello() {
    fmt.Println("Hello!")
}

func main() {
    // 将函数赋值给变量
    greeting := sayHello

    // 调用通过变量引用的函数
    greeting() // 输出: Hello!
}

输出：

复制代码 
Hello!
将函数作为参数传递

函数可以作为参数传递给其他函数，允许更高层次的抽象和代码复用。

示例：

go 复制代码 
package main

import "fmt"

// 定义一个函数类型
type operation func(int, int) int

// 定义一个函数，接受另一个函数作为参数
func compute(a int, b int, op operation) int {
    return op(a, b)
}

// 定义具体的操作函数
func add(a int, b int) int {
    return a + b
}

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

func main() {
    sum := compute(5, 3, add)
    product := compute(5, 3, multiply)

    fmt.Println("Sum:", sum)         // 输出: Sum: 8
    fmt.Println("Product:", product) // 输出: Product: 15
}

输出：

复制代码 
Sum: 8
Product: 15

解释：

  • operation是一个函数类型，接受两个整数并返回一个整数。
  • compute函数接受两个整数和一个operation类型的函数作为参数，并返回操作结果。
  • add和multiply是具体的操作函数，分别实现加法和乘法。
将函数作为返回值

函数可以作为其他函数的返回值，允许动态生成函数或实现高阶函数的功能。

示例：

go 复制代码 
package main

import "fmt"

// 定义一个函数，返回一个函数，该返回函数会将输入数值加上指定的值
func adder(x int) func(int) int {
    return func(y int) int {
        return x + y
    }
}

func main() {
    addFive := adder(5)
    addTen := adder(10)

    fmt.Println("5 + 3 =", addFive(3))  // 输出: 5 + 3 = 8
    fmt.Println("10 + 7 =", addTen(7))  // 输出: 10 + 7 = 17
}

输出：

复制代码 
5 + 3 = 8
10 + 7 = 17

解释：

  • adder函数接受一个整数x，并返回一个匿名函数，该匿名函数接受另一个整数y，返回x + y的结果。
  • addFive和addTen分别是不同的闭包实例，绑定了不同的x值。
使用函数作为数据结构的元素

函数可以被存储在数据结构中，如切片、Map等，提供更高的灵活性和扩展性。

示例1：将函数存储在切片中

go 复制代码 
package main

import "fmt"

// 定义一个函数类型
type operation func(int, int) int

func main() {
    // 创建一个存储函数的切片
    operations := []operation{
        func(a, b int) int { return a + b },
        func(a, b int) int { return a - b },
        func(a, b int) int { return a * b },
        func(a, b int) int { return a / b },
    }

    a, b := 20, 5
    for _, op := range operations {
        result := op(a, b)
        fmt.Println(result)
    }
}

输出：

复制代码 
25
15
100
4

示例2：将函数存储在Map中

go 复制代码 
package main

import "fmt"

// 定义一个函数类型
type operation func(int, int) int

func main() {
    // 创建一个存储函数的Map
    operations := map[string]operation{
        "add":      func(a, b int) int { return a + b },
        "subtract": func(a, b int) int { return a - b },
        "multiply": func(a, b int) int { return a * b },
        "divide":   func(a, b int) int { return a / b },
    }

    a, b := 15, 3
    for name, op := range operations {
        result := op(a, b)
        fmt.Printf("%s: %d\n", name, result)
    }
}

输出：

复制代码 
add: 18
subtract: 12
multiply: 45
divide: 5

解释：

  • 在第一个示例中，函数被存储在切片中，可以通过索引访问和调用。
  • 在第二个示例中，函数被存储在Map中，通过键名访问和调用，提供更具语义化的调用方式。
函数作为接口的实现

Go语言中的接口类型可以包含函数类型，使得接口的实现更加灵活。

示例：

go 复制代码 
package main

import "fmt"

// 定义一个接口，包含一个函数方法
type Greeter interface {
    Greet(name string) string
}

// 定义一个结构体，实现Greeter接口
type Person struct {
    greeting string
}

// 实现Greet方法
func (p Person) Greet(name string) string {
    return fmt.Sprintf("%s, %s!", p.greeting, name)
}

func main() {
    var greeter Greeter
    greeter = Person{greeting: "Hello"}

    message := greeter.Greet("Alice")
    fmt.Println(message) // 输出: Hello, Alice!
}

输出：

复制代码 
Hello, Alice!

解释：

  • Greeter接口定义了一个Greet方法。
  • Person结构体实现了Greet方法，从而满足Greeter接口。
  • 通过接口类型变量greeter可以调用具体实现的Greet方法。
相关推荐
懂点Tech2 小时前
ctfshow MISC入门图片篇(信息附加)：misc41解题思路
开发语言·python
金銀銅鐵3 小时前
[Java] 用 GUI 展示 EnumSet 增减元素时的内部变化（上）
java·后端·ai编程
catchadmin3 小时前
PHP 8.7 协程新提案 让跨协程代码共享请求身份
开发语言·php
念何架构之路3 小时前
go-grpc设计思想
开发语言·后端·golang
system_error_x4 小时前
SpringBoot 集成 Thymeleaf 简洁入门
java·spring boot·后端
酷炫码神4 小时前
Day 10｜Pinia 状态管理：把散落在各组件的数据，收进一个全局仓库
android·开发语言·javascript
microrain4 小时前
SagooIoT 的缓存换后端只改一行配置，文件后端连 Redis 都不需要
物联网·缓存·golang·sagooiot
Elastic 中国社区官方博客5 小时前
我们如何通过 70 多个拉取请求，将 OpenTelemetry Java agent 迁移到 invokedynamic
java·大数据·开发语言·elasticsearch·搜索引擎·全文检索·es
tyn1885 小时前
记录本地安装nacos服务的方法及异常
java·开发语言
步行cgn5 小时前
Spring MVC 视图机制的核心接口与类
java·开发语言·后端·spring·mvc
热门推荐
01国内可直接用、免费额度/永久免费的大模型API清单（含 SiliconFlow、火山、阿里、智谱、百度、Kimi、DeepSeek、DMXAPI 等）02如何新建文件夹？ 电脑新建文件夹的4种方法03GitHub 镜像站点04ai安全工具:CyberStrikeAI安装部署与使用05历年考研数学一、数学二、数学三真题试卷及答案PDF06几个好用的ip纯净度检测网站07Windows 10/11 如何退出微软账户并改用本地账户登录（含找不到选项的解决方法）08昇腾910B系列芯片完全指南：四款型号对比、服务器选型与大模型部署实战09苹果iPA游戏软件资源下载网站10乙二醇水溶液物性参数