编程笔记 Golang基础 026 函数

Go语言中的函数是其核心特性之一，用于封装代码逻辑并实现模块化编程。

以下是对Go语言中函数的详细解释和示例：

一、函数定义与调用

定义函数的基本格式：

func 函数名(参数列表)(返回值列表) {
    函数体
}
1
2
3

例如，定义一个简单的加法函数：

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

// 调用函数
result := add(3, 5)
fmt.Println("The sum is:", result)
1
2
3
4
5
6
7
8

二、参数传递

• Go支持按值（value）或按引用（pointer）传参。默认情况下，函数接收的是参数的副本（对于基本类型），如果需要修改原变量的值，可以传入指针。

  // 按值传递的例子
  func increaseByOne(value int) int {
      value = value + 1
      return value
  }
  
  originalValue := 10
  newValue := increaseByOne(originalValue)
  fmt.Println("newValue:", newValue)   // 输出：11
  fmt.Println("originalValue:", originalValue)   // 输出：10，因为原始值未改变
  
  // 按引用传递的例子，使用指针
  func increaseByOnePointer(value *int) {
      *value = *value + 1
  }
  
  pointerValue := 10
  increaseByOnePointer(&pointerValue)
  fmt.Println("pointerValue:", pointerValue)   // 输出：11，因为通过指针修改了原始值
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19

三、返回值

• Go函数可以有多个返回值，这些返回值在函数签名中紧跟参数列表后面声明。

  // 返回两个值的函数
  func divide(x int, y int) (quotient int, remainder int) {
      quotient = x / y
      remainder = x % y
      return
  }
  
  q, r := divide(10, 3)
  fmt.Println("Quotient:", q)   // 输出：3
  fmt.Println("Remainder:", r)   // 输出：1
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10

四、匿名函数（没有名字的函数）

• Go语言支持匿名函数（也称为lambda表达式），可以赋给变量、作为参数传递或者直接执行。

  // 匿名函数赋给变量
  square := func(x int) int {
      return x * x
  }
  result := square(4)
  fmt.Println(result)   // 输出：16
  
  // 作为参数传递
  numbers := []int{1, 2, 3, 4, 5}
  squaredNumbers := make([]int, len(numbers))
  for i, v := range numbers {
      squaredNumbers[i] = func(v int) int { return v * v }(v) // 在这里直接执行匿名函数
  }
  
  // 使用闭包特性
  funcs := make([]func() int, 5)
  for i := 0; i < 5; i++ {
      funcs[i] = func() int {
          return i * i
      } // 这里由于闭包特性，每个函数记住的是循环结束后的i值
  }
  fmt.Println(funcs[2]()) // 输出：9
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22

五、变参函数

• Go还支持可变数量的参数，通过...操作符来表示不定数量的参数。

  // 可变参数函数
  func sum(nums ...int) int {
      total := 0
      for _, num := range nums {
          total += num
      }
      return total
  }
  
  fmt.Println(sum(1, 2, 3, 4, 5))   // 输出：15
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10

六、defer语句

• defer关键字用于在函数退出前（无论是正常返回还是panic异常后recover）执行某个函数或方法调用，通常用于资源清理等场景。

  func openAndCloseFile(fileName string) error {
      file, err := os.Open(fileName)
      if err != nil {
          return err
      }
      defer file.Close() // 确保文件最终会被关闭
  
      // 执行其他对file的操作...
      // ...
  
      return nil
  }
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12

七、 panic和recover

• panic用于触发运行时恐慌，导致当前goroutine立即停止，并开始执行延迟函数（如果有）直到调用recover恢复。

  func main() {
      defer func() {
          if r := recover(); r != nil {
              fmt.Println("Recovered from panic:", r)
          }
      }()
      
      panic("A panic occurred!") // 触发panic
      fmt.Println("This line won't be executed.")
  }
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10

以上就是Go语言中关于函数的一些关键概念和示例。

小结

函数在编程中的非常重要：

1. 代码重用：通过定义函数，我们可以将常用的或者复杂的逻辑封装起来，使得同一段代码可以在程序的不同地方重复使用，避免了重复编写相同的代码。

2. 模块化编程：函数是实现模块化设计的基础单元。通过将大问题分解为多个独立的、可管理的小功能（即函数），可以简化复杂度，便于开发和维护。

3. 抽象与信息隐藏：函数允许我们将实现细节隐藏在函数内部，仅暴露必要的接口（函数名、参数列表和返回值）。这样，调用者无需关心具体实现，只需关注输入输出，有助于降低耦合度，提高代码的稳定性和可扩展性。

4. 逻辑划分：函数使代码逻辑更加清晰明了。每个函数通常只完成一个特定的任务或解决一个小问题，有利于程序员理解和调试代码。

5. 测试便利：具有明确输入和输出的函数方便进行单元测试，能够有效保证软件质量。

6. 协程友好：Go语言支持并发编程，函数作为执行的基本单位，在goroutine中发挥重要作用，可以轻松创建并行任务以提升程序性能。

7. 高级特性支持：如闭包、匿名函数等，提供了更多灵活高效的编程手段，适应各种复杂场景的需求。例如，Go语言中的defer语句用于确保函数退出前的清理操作，而匿名函数则可用于实现策略模式、回调机制等功能。