第四章：函数
4.1 函数基础
函数定义与调用
package main
import "fmt"
// 基本函数定义
func sayHello() {
fmt.Println("Hello, Go!")
}
// 带参数的函数
func greet(name string) {
fmt.Printf("Hello, %s!\\n", name)
}
// 带返回值的函数
func add(a, b int) int {
return a + b
}
// 多返回值函数
func divide(a, b float64) (float64, error) {
if b == 0 {
return 0, fmt.Errorf("除数不能为0")
}
return a / b, nil
}
// 命名返回值函数
func rectangle(width, height float64) (area, perimeter float64) {
area = width * height
perimeter = 2 * (width + height)
return // 裸返回
}
func main() {
// 调用函数
sayHello()
greet("张三")
// 调用带返回值的函数
result := add(10, 20)
fmt.Printf("10 + 20 = %d\\n", result)
// 调用多返回值函数
quotient, err := divide(10, 3)
if err != nil {
fmt.Println("错误:", err)
} else {
fmt.Printf("10 / 3 = %.2f\\n", quotient)
}
// 调用命名返回值函数
area, perimeter := rectangle(5, 3)
fmt.Printf("面积: %.2f, 周长: %.2f\\n", area, perimeter)
}
4.2 函数参数
可变参数
package main
import "fmt"
// 可变参数函数
func sum(numbers …int) int {
total := 0
for _, num := range numbers {
total += num
}
return total
}
// 混合参数
func printInfo(name string, scores …int) {
fmt.Printf("姓名: %s\\n", name)
fmt.Printf("分数: %v\\n", scores)
fmt.Printf("平均分: %.2f\\n", float64(sum(scores…))/float64(len(scores)))
}
// 参数为函数类型
func calculate(a, b int, operation func(int, int) int) int {
return operation(a, b)
}
func main() {
// 可变参数调用
fmt.Println("sum(1,2,3):", sum(1, 2, 3))
fmt.Println("sum(1,2,3,4,5):", sum(1, 2, 3, 4, 5))
// 传递切片
nums := []int{10, 20, 30}
fmt.Println("sum(nums…):", sum(nums…))
// 混合参数调用
printInfo("张三", 90, 85, 95)
// 函数作为参数
add := func(a, b int) int { return a + b }
multiply := func(a, b int) int { return a * b }
fmt.Printf("10 + 20 = %d\\n", calculate(10, 20, add))
fmt.Printf("10 * 20 = %d\\n", calculate(10, 20, multiply))
}
值传递与引用传递
package main
import "fmt"
// 值传递
func modifyValue(x int) {
x = 100
fmt.Printf("函数内x: %d\\n", x)
}
// 引用传递 (通过指针)
func modifyPointer(x *int) {
*x = 100
fmt.Printf("函数内*x: %d\\n", *x)
}
// 切片是引用类型
func modifySlice(s []int) {
s[0] = 100
fmt.Printf("函数内s: %v\\n", s)
}
// map是引用类型
func modifyMap(m map[string]int) {
m["score"] = 100
fmt.Printf("函数内m: %v\\n", m)
}
func main() {
// 值传递
x := 10
fmt.Printf("调用前x: %d\\n", x)
modifyValue(x)
fmt.Printf("调用后x: %d\\n", x)
// 引用传递
fmt.Println()
y := 10
fmt.Printf("调用前y: %d\\n", y)
modifyPointer(&y)
fmt.Printf("调用后y: %d\\n", y)
// 切片传递
fmt.Println()
s := []int{1, 2, 3}
fmt.Printf("调用前s: %v\\n", s)
modifySlice(s)
fmt.Printf("调用后s: %v\\n", s)
// map传递
fmt.Println()
m := map[string]int{"score": 90}
fmt.Printf("调用前m: %v\\n", m)
modifyMap(m)
fmt.Printf("调用后m: %v\\n", m)
}
4.3 匿名函数与闭包
匿名函数
package main
import "fmt"
func main() {
// 匿名函数定义并调用
func() {
fmt.Println("匿名函数被调用")
}()
// 带参数的匿名函数
func(name string) {
fmt.Printf("Hello, %s!\\n", name)
}("张三")
// 匿名函数赋值给变量
add := func(a, b int) int {
return a + b
}
fmt.Printf("10 + 20 = %d\\n", add(10, 20))
// 匿名函数作为参数
result := func(a, b int, op func(int, int) int) int {
return op(a, b)
}(10, 20, func(a, b int) int {
return a * b
})
fmt.Printf("10 * 20 = %d\\n", result)
// 匿名函数切片
operations := []func(int, int) int{
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 },
}
for _, op := range operations {
fmt.Printf("结果: %d\\n", op(10, 2))
}
}
闭包
package main
import "fmt"
// 计数器闭包
func counter() func() int {
count := 0
return func() int {
count++
return count
}
}
// 累加器闭包
func accumulator(initial int) func(int) int {
sum := initial
return func(x int) int {
sum += x
return sum
}
}
// 闭包实现斐波那契数列
func fibonacci() func() int {
a, b := 0, 1
return func() int {
result := a
a, b = b, a+b
return result
}
}
// 闭包实现缓存
func memoize(fn func(int) int) func(int) int {
cache := make(map[int]int)
return func(x int) int {
if val, ok := cache[x]; ok {
fmt.Printf("缓存命中: %d -> %d\\n", x, val)
return val
}
result := fn(x)
cache[x] = result
fmt.Printf("计算结果: %d -> %d\\n", x, result)
return result
}
}
func main() {
// 计数器
fmt.Println("计数器示例:")
c := counter()
fmt.Println(c()) // 1
fmt.Println(c()) // 2
fmt.Println(c()) // 3
// 另一个计数器实例
c2 := counter()
fmt.Println(c2()) // 1 (独立的计数器)
// 累加器
fmt.Println("\\n累加器示例:")
acc := accumulator(0)
fmt.Println(acc(10)) // 10
fmt.Println(acc(20)) // 30
fmt.Println(acc(30)) // 60
// 斐波那契数列
fmt.Println("\\n斐波那契数列:")
fib := fibonacci()
for i := 0; i < 10; i++ {
fmt.Printf("%d ", fib())
}
fmt.Println()
// 缓存示例
fmt.Println("\\n缓存示例:")
square := func(x int) int {
return x * x
}
cachedSquare := memoize(square)
fmt.Println(cachedSquare(4)) // 计算
fmt.Println(cachedSquare(4)) // 缓存
fmt.Println(cachedSquare(5)) // 计算
fmt.Println(cachedSquare(5)) // 缓存
}
4.4 方法
方法定义
package main
import (
"fmt"
"math"
)
// 定义结构体
type Rectangle struct {
Width float64
Height float64
}
// 值接收者方法
func (r Rectangle) Area() float64 {
return r.Width * r.Height
}
func (r Rectangle) Perimeter() float64 {
return 2 * (r.Width + r.Height)
}
// 指针接收者方法
func (r *Rectangle) Scale(factor float64) {
r.Width *= factor
r.Height *= factor
}
// 定义圆形结构体
type Circle struct {
Radius float64
}
func (c Circle) Area() float64 {
return math.Pi * c.Radius * c.Radius
}
func (c Circle) Perimeter() float64 {
return 2 * math.Pi * c.Radius
}
// 接口
type Shape interface {
Area() float64
Perimeter() float64
}
func printShapeInfo(s Shape) {
fmt.Printf("面积: %.2f\\n", s.Area())
fmt.Printf("周长: %.2f\\n", s.Perimeter())
}
func main() {
// 矩形
rect := Rectangle{Width: 10, Height: 5}
fmt.Println("矩形:")
fmt.Printf("面积: %.2f\\n", rect.Area())
fmt.Printf("周长: %.2f\\n", rect.Perimeter())
// 修改矩形大小
rect.Scale(2)
fmt.Printf("缩放后面积: %.2f\\n", rect.Area())
// 圆形
circle := Circle{Radius: 5}
fmt.Println("\\n圆形:")
fmt.Printf("面积: %.2f\\n", circle.Area())
fmt.Printf("周长: %.2f\\n", circle.Perimeter())
// 使用接口
fmt.Println("\\n使用接口:")
printShapeInfo(rect)
printShapeInfo(circle)
}
4.5 init函数
package main
import "fmt"
var globalConfig map[string]string
// init函数在main之前自动执行
func init() {
fmt.Println("init函数执行")
globalConfig = map[string]string{
"host": "localhost",
"port": "8080",
"db": "mydb",
}
}
// 多个init函数按顺序执行
func init() {
fmt.Println("第二个init函数执行")
globalConfig["version"] = "1.0.0"
}
func main() {
fmt.Println("main函数执行")
fmt.Printf("配置: %v\\n", globalConfig)
}
4.6 递归函数
package main
import "fmt"
// 阶乘
func factorial(n int) int {
if n <= 1 {
return 1
}
return n * factorial(n–1)
}
// 斐波那契数列
func fib(n int) int {
if n <= 1 {
return n
}
return fib(n–1) + fib(n–2)
}
// 带记忆化的斐波那契
func fibMemo(n int, memo map[int]int) int {
if n <= 1 {
return n
}
if val, ok := memo[n]; ok {
return val
}
memo[n] = fibMemo(n–1, memo) + fibMemo(n–2, memo)
return memo[n]
}
// 二叉树结构
type TreeNode struct {
Value int
Left *TreeNode
Right *TreeNode
}
// 前序遍历
func preorder(root *TreeNode) {
if root == nil {
return
}
fmt.Printf("%d ", root.Value)
preorder(root.Left)
preorder(root.Right)
}
// 中序遍历
func inorder(root *TreeNode) {
if root == nil {
return
}
inorder(root.Left)
fmt.Printf("%d ", root.Value)
inorder(root.Right)
}
// 后序遍历
func postorder(root *TreeNode) {
if root == nil {
return
}
postorder(root.Left)
postorder(root.Right)
fmt.Printf("%d ", root.Value)
}
// 汉诺塔
func hanoi(n int, from, to, aux string) {
if n == 1 {
fmt.Printf("移动盘子 1 从 %s 到 %s\\n", from, to)
return
}
hanoi(n–1, from, aux, to)
fmt.Printf("移动盘子 %d 从 %s 到 %s\\n", n, from, to)
hanoi(n–1, aux, to, from)
}
func main() {
// 阶乘
fmt.Printf("5! = %d\\n", factorial(5))
// 斐波那契
fmt.Printf("fib(10) = %d\\n", fib(10))
// 带记忆化的斐波那契
memo := make(map[int]int)
fmt.Printf("fibMemo(10) = %d\\n", fibMemo(10, memo))
// 二叉树遍历
// 1
// / \\
// 2 3
// / \\
// 4 5
root := &TreeNode{
Value: 1,
Left: &TreeNode{
Value: 2,
Left: &TreeNode{Value: 4},
Right: &TreeNode{Value: 5},
},
Right: &TreeNode{Value: 3},
}
fmt.Println("\\n前序遍历:")
preorder(root)
fmt.Println("\\n中序遍历:")
inorder(root)
fmt.Println("\\n后序遍历:")
postorder(root)
// 汉诺塔
fmt.Println("\\n\\n汉诺塔 (3个盘子):")
hanoi(3, "A", "C", "B")
}
4.7 实战案例：学生成绩管理系统
package main
import (
"fmt"
"sort"
"strings"
)
// Student 学生结构体
type Student struct {
ID int
Name string
Scores map[string]int
}
// NewStudent 创建新学生
func NewStudent(id int, name string) *Student {
return &Student{
ID: id,
Name: name,
Scores: make(map[string]int),
}
}
// AddScore 添加成绩
func (s *Student) AddScore(subject string, score int) {
s.Scores[subject] = score
}
// GetAverage 计算平均分
func (s *Student) GetAverage() float64 {
if len(s.Scores) == 0 {
return 0
}
total := 0
for _, score := range s.Scores {
total += score
}
return float64(total) / float64(len(s.Scores))
}
// GetHighestScore 获取最高分
func (s *Student) GetHighestScore() (string, int) {
highestSubject := ""
highestScore := 0
for subject, score := range s.Scores {
if score > highestScore {
highestScore = score
highestSubject = subject
}
}
return highestSubject, highestScore
}
// GradeManager 成绩管理器
type GradeManager struct {
Students map[int]*Student
}
// NewGradeManager 创建管理器
func NewGradeManager() *GradeManager {
return &GradeManager{
Students: make(map[int]*Student),
}
}
// AddStudent 添加学生
func (gm *GradeManager) AddStudent(student *Student) {
gm.Students[student.ID] = student
}
// GetStudent 获取学生
func (gm *GradeManager) GetStudent(id int) (*Student, bool) {
student, ok := gm.Students[id]
return student, ok
}
// GetTopStudents 获取前N名学生
func (gm *GradeManager) GetTopStudents(n int) []*Student {
students := make([]*Student, 0, len(gm.Students))
for _, s := range gm.Students {
students = append(students, s)
}
sort.Slice(students, func(i, j int) bool {
return students[i].GetAverage() > students[j].GetAverage()
})
if n > len(students) {
n = len(students)
}
return students[:n]
}
// GetSubjectAverage 获取某科目平均分
func (gm *GradeManager) GetSubjectAverage(subject string) float64 {
total := 0
count := 0
for _, student := range gm.Students {
if score, ok := student.Scores[subject]; ok {
total += score
count++
}
}
if count == 0 {
return 0
}
return float64(total) / float64(count)
}
// PrintReport 打印报告
func (gm *GradeManager) PrintReport() {
fmt.Println(strings.Repeat("=", 60))
fmt.Println("学生成绩管理报告")
fmt.Println(strings.Repeat("=", 60))
// 按平均分排序
students := gm.GetTopStudents(len(gm.Students))
for _, student := range students {
fmt.Printf("\\n学生: %s (ID: %d)\\n", student.Name, student.ID)
fmt.Println("各科成绩:")
for subject, score := range student.Scores {
fmt.Printf(" %s: %d\\n", subject, score)
}
highestSubject, highestScore := student.GetHighestScore()
fmt.Printf("最高分: %s – %d分\\n", highestSubject, highestScore)
fmt.Printf("平均分: %.2f\\n", student.GetAverage())
}
// 各科平均分
fmt.Println("\\n" + strings.Repeat("-", 60))
fmt.Println("各科平均分:")
subjects := make(map[string]bool)
for _, student := range gm.Students {
for subject := range student.Scores {
subjects[subject] = true
}
}
for subject := range subjects {
avg := gm.GetSubjectAverage(subject)
fmt.Printf(" %s: %.2f\\n", subject, avg)
}
fmt.Println(strings.Repeat("=", 60))
}
func main() {
// 创建管理器
manager := NewGradeManager()
// 创建学生
s1 := NewStudent(1, "张三")
s1.AddScore("语文", 90)
s1.AddScore("数学", 85)
s1.AddScore("英语", 92)
s2 := NewStudent(2, "李四")
s2.AddScore("语文", 88)
s2.AddScore("数学", 95)
s2.AddScore("英语", 80)
s3 := NewStudent(3, "王五")
s3.AddScore("语文", 95)
s3.AddScore("数学", 90)
s3.AddScore("英语", 88)
s4 := NewStudent(4, "赵六")
s4.AddScore("语文", 82)
s4.AddScore("数学", 78)
s4.AddScore("英语", 90)
// 添加到管理器
manager.AddStudent(s1)
manager.AddStudent(s2)
manager.AddStudent(s3)
manager.AddStudent(s4)
// 打印报告
manager.PrintReport()
// 获取前2名
fmt.Println("\\n前2名学生:")
top2 := manager.GetTopStudents(2)
for i, student := range top2 {
fmt.Printf("第%d名: %s – 平均分: %.2f\\n", i+1, student.Name, student.GetAverage())
}
}
