Go基础：Go语言函数和方法详解

文章目录

- 一、函数的基本操作
- - [1.1 定义与语法](#1.1 定义与语法)
  - [1.2 函数的返回值](#1.2 函数的返回值)
  - [1.3 函数参数传递](#1.3 函数参数传递)
- 二、匿名函数与闭包
- - [2.1 匿名函数](#2.1 匿名函数)
  - [2.2 闭包](#2.2 闭包)
- 三、函数作为参数和返回值
- - [3.1 函数作为参数](#3.1 函数作为参数)
  - [3.2 函数作为返回值](#3.2 函数作为返回值)
- 四、Go语言中方法详解

一、函数的基本操作

1.1 定义与语法

Go 语言中的函数是程序的基本组成单元，它允许将代码组织成可重用的模块，提高代码的可读性和可维护性。Go 语言的函数由 func 关键字定义，基本语法如下：

go 复制代码

func functionName(parameterList) (returnTypeList) {
    // 函数体
}

示例代码

go 复制代码

package main
import "fmt"
// 定义一个简单的加法函数
func add(a int, b int) int {
    return a + b
}
func main() {
    result := add(3, 5)
    fmt.Println("3 + 5 =", result)  // 输出：3 + 5 = 8
}

1.2 函数的返回值

1. 多返回值：Go 语言支持函数返回多个值，这在处理错误或返回多个结果时非常实用。示例代码

go 复制代码

package main
import "fmt"
// 返回两个数的和与差
func sumAndDiff(a, b int) (int, int) {
    sum := a + b
    diff := a - b
    return sum, diff
}
func main() {
    sum, diff := sumAndDiff(10, 5)
    fmt.Println("Sum:", sum, "Diff:", diff)  // 输出：Sum: 15 Diff: 5
}

2. 命名返回值 ：函数可以命名返回值，这样在函数体中可以直接使用这些变量，并在 return 时省略表达式。示例代码

go 复制代码

package main
import "fmt"
// 使用命名返回值
func divide(a, b int) (quotient int, remainder int) {
    quotient = a / b
    remainder = a % b
    return
}
func main() {
    q, r := divide(10, 3)
    fmt.Println("Quotient:", q, "Remainder:", r)  // 输出：Quotient: 3 Remainder: 1
}

1.3 函数参数传递

1. 按值传递

默认情况下，Go 语言的函数参数是按值传递的，即函数内部对参数的修改不会影响外部变量。示例代码

go 复制代码

package main
import "fmt"
// 按值传递
func modifyValue(x int) {
    x = 100
}
func main() {
    a := 10
    modifyValue(a)
    fmt.Println("a after modifyValue:", a)  // 输出：a after modifyValue: 10
}

2. 按指针传递：通过指针传递参数，可以在函数内部修改外部变量的值。示例代码

go 复制代码

package main
import "fmt"
// 按指针传递
func modifyPointer(x *int) {
    *x = 100
}
func main() {
    a := 10
    modifyPointer(&a)
    fmt.Println("a after modifyPointer:", a)  // 输出：a after modifyPointer: 100
}

二、匿名函数与闭包

2.1 匿名函数

匿名函数是没有名字的函数，通常用于需要临时定义函数的场景。示例代码

go 复制代码

package main
import "fmt"
func main() {
    // 定义并调用匿名函数
    func() {
        fmt.Println("Hello from anonymous function!")
    }()
}

输出：

复制代码

Hello from anonymous function!

2.2 闭包

闭包是由函数及其相关引用环境组合而成的实体。闭包可以访问外部作用域中的变量，即使外部函数已经返回。示例代码

go 复制代码

package main
import "fmt"
// 返回一个闭包
func getCounter() func() int {
    count := 0
    return func() int {
        count++
        return count
    }
}
func main() {
    counter := getCounter()
    fmt.Println(counter()) // 输出 1
    fmt.Println(counter()) // 输出 2
    fmt.Println(counter()) // 输出 3
}

三、函数作为参数和返回值

3.1 函数作为参数

Go 语言支持将函数作为参数传递给其他函数。示例代码

go 复制代码

package main
import "fmt"
// 定义一个函数类型
type operation func(int, int) int
// 将函数作为参数
func compute(a, b int, op operation) int {
    return op(a, b)
}
func main() {
    sum := compute(3, 5, func(a, b int) int {
        return a + b
    })
    fmt.Println("Sum:", sum)  // 输出：Sum: 8
}

3.2 函数作为返回值

函数也可以作为其他函数的返回值。示例代码

go 复制代码

package main
import "fmt"
// 返回一个函数
func getMultiplier(factor int) func(int) int {
    return func(x int) int {
        return x * factor
    }
}
func main() {
    multiplyBy2 := getMultiplier(2)
    fmt.Println(multiplyBy2(5)) // 输出 10
}

四、Go语言中方法详解

在 Go 语言中，方法和函数是两个概念，但又非常相似，不同点在于方法必须要有一个接收者，这个接收者是一个类型，这样方法就和这个类型绑定在一起，称为这个类型的方法。函数属于一个包，方法属于一个类型，所以方法也可以简单地理解为和一个类型关联的函数。

不管是函数还是方法，它们都是代码复用的第一步，也是代码职责分离的基础。掌握好函数和方法，可以让你写出职责清晰、任务明确、可复用的代码，提高开发效率、降低 Bug 率。

在下面的示例中，type Age uint 表示定义一个新类型 Age，该类型等价于 uint，可以理解为类型 uint 的重命名。其中 type 是 Go 语言关键字，表示定义一个类型。

go 复制代码

type Age uint
func (age Age) String(){
    fmt.Println("the age is",age)
}

示例中方法 String() 就是类型 Age 的方法，类型 Age 是方法 String() 的接收者。和函数不同，定义方法时会在关键字 func 和方法名 String 之间加一个接收者 (age Age) ，接收者使用小括号包围。

接收者的定义和普通变量、函数参数等一样，前面是变量名，后面是接收者类型。现在方法 String() 就和类型 Age 绑定在一起了，String() 是类型 Age 的方法。定义了接收者的方法后，就可以通过点操作符调用方法，如下面的代码所示：

go 复制代码

func main() {
    age:=Age(25)
    age.String()
}

运行这段代码，可以看到如下输出：

go 复制代码

the age is 25