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

一、函数的基本操作

1.1 定义与语法

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

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

示例代码

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 语言支持函数返回多个值，这在处理错误或返回多个结果时非常实用。示例代码

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

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

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

1.3 函数参数传递

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

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

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

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

二、匿名函数与闭包

2.1 匿名函数

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

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

输出：

Hello from anonymous function!

2.2 闭包

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

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

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

3.1 函数作为参数

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 函数作为返回值

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

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 语言关键字，表示定义一个类型。

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 的方法。定义了接收者的方法后，就可以通过点操作符调用方法，如下面的代码所示：

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

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

the age is 25

接收者就是函数和方法的最大不同，此外，上面所讲到的函数具备的能力，方法也都具备。