07 - Go 函数（上）：定义、参数、返回值与实战技巧

文章目录

• [🚀 07 - Go 函数（上）：定义、参数、返回值与实战技巧](#🚀 07 - Go 函数（上）：定义、参数、返回值与实战技巧)
• 为什么要使用函数？
• 函数的基本定义
• 参数详解（必须掌握）
• • 多参数简写
  • 不同类型参数
  • 参数是值传递（重点）
• 返回值详解（核心重点🔥）
• • 单返回值
  • [多返回值（Go 特色）](#多返回值（Go 特色）)
  • 忽略返回值
  • [返回 error（开发必备）](#返回 error（开发必备）)
• 命名返回值（面试高频🔥）
• 可变参数（...）
• 实战案例（必须掌握）
• • [📌 求数组最大值](#📌 求数组最大值)
  • [📌 封装计算逻辑](#📌 封装计算逻辑)
• 小结（建议收藏⭐）
• [🎯 最后说一句](#🎯 最后说一句)

---

🚀 07 - Go 函数（上）：定义、参数、返回值与实战技巧

在学习 Go 语言的过程中，函数（Function）是必须牢牢掌握的核心基础之一 。

无论是日常开发、框架源码阅读，还是面试，函数都是高频出现的知识点。

很多人刚学时觉得函数很简单，但一到实际使用，就会遇到各种问题：

• 多返回值怎么优雅使用？
• 命名返回值到底有什么用？
• ... 可变参数是怎么回事？
• 为什么 Go 推荐返回 error？

👉 本文带你从 0 到 1 吃透 Go 函数基础，并配合实战案例，让你真正掌握。

---

为什么要使用函数？

在没有函数之前，代码可能是这样的：

package main

import "fmt"

func main() {
	a := 10
	b := 20
	fmt.Println(a + b)

	c := 30
	d := 40
	fmt.Println(c + d)
}

输出：

30
70

👉 问题：

• 代码重复
• 可读性差
• 难以维护

---

✅ 使用函数优化：

package main

import "fmt"

func add(a, b int) int {
	return a + b
}

func main() {
	fmt.Println(add(10, 20))
	fmt.Println(add(30, 40))
}

输出：

30
70

👉 优势：

• 代码复用
• 逻辑清晰
• 易于维护

---

函数的基本定义

Go 中函数定义格式如下：

func 函数名(参数列表) 返回值类型 {
    // 函数体
}

示例：

func add(a int, b int) int { // 因为a,b都是int，所以可以简写func add(a, b int) int 
	return a + b
}

调用方式：

result := add(1, 2)
fmt.Println(result) // 输出结果：3

---

参数详解（必须掌握）

多参数简写

Go 支持相同类型参数的简写：

func add(a, b int) int {
	return a + b
}

👉 等价于：

func add(a int, b int) int

---

不同类型参数

func printInfo(id int, name string) {
	fmt.Println(id, name)
}

---

参数是值传递（重点）

package main

import "fmt"

func change(a int) {
	fmt.Println("three:", a)
	a = 100
	fmt.Println("four:", a)
}
func main() {
	x := 10
	fmt.Println("one:", x)
	change(x)
	fmt.Println("two:", x)
}

输出：

one: 10
three: 10
four: 100
two: 10

👉 说明：

• Go 默认是值传递
• 函数内部修改不会影响外部变量

---

返回值详解（核心重点🔥）

单返回值

package main

import "fmt"

func sum(a, b int) int {
	return a + b
}
func main() {
	fmt.Println(sum(1, 2))
}

输出：

3

---

多返回值（Go 特色）

func calc(a, b int) (int, int) {
	return a + b, a - b
}

调用：

x, y := calc(10, 5)
fmt.Println(x, y)

---

忽略返回值

x, _ := calc(10, 5)

👉 _ 表示忽略变量（非常常用）

package main

import "fmt"

func calc(a, b int) (int, int) {
	sum := a + b
	diff := a - b

	return sum, diff
}

func main() {
	x, y := calc(5, 10)
	fmt.Println(x, y)
	z, _ := calc(5, 10)
	fmt.Println(z)
}

输出：

15 -5
15

---

返回 error（开发必备）

Go 中常见写法：

func divide(a, b int) (int, error) {
	if b == 0 {
		return 0, fmt.Errorf("除数不能为0")
	}
	return a / b, nil
}

调用：

res, err := divide(10, 0)
if err != nil {
	fmt.Println("发生错误：", err)
	return
} else {
	fmt.Println("结果是：", res)
}

👉 这是 Go 的错误处理标准模式

package main

import "fmt"

func divide(a, b int) (int, error) {
	if b == 0 {
		return 0, fmt.Errorf("除数不能为0")
	}
	return a / b, nil
}

func main() {
	res, err := divide(10, 0)
	if err != nil {
		fmt.Println("发生错误：", err)
		return
	} else {
		fmt.Println("结果是：", res)
	}
}

输出：

错误： 除数不能为0

---

命名返回值（面试高频🔥）

package main

import "fmt"

func calc(a, b int) (sum int, diff int) {
	sum = a + b
	diff = a - b
	return //看这里，只有一个return
}

func main() {
	x, y := calc(5, 10)
	fmt.Println(x, y)
}

输出：

15 -5

👉 特点：

• 返回值提前声明
• return 可以省略变量

---

⚠️ 注意不要滥用：

func test() (res int) {
	res = 100
	return
}

👉 虽然简洁，但可读性可能变差（团队开发需谨慎）

---

可变参数（...）

当参数个数不固定时，可以使用 ...

package main

import "fmt"

func sum(nums ...int) int {
	total := 0
	for _, v := range nums {
		total += v
	}
	return total
}
func main() {
	fmt.Println("sum():", sum())
	fmt.Println("sum(1):", sum(1))
	fmt.Println("sum(1, 2):", sum(1, 2))
	fmt.Println("sum(1, 2, 3):", sum(1, 2, 3))
}

输出：

sum(): 0
sum(1): 1
sum(1, 2): 3
sum(1, 2, 3): 6

👉 本质：

• nums 是一个 slice（切片）

---

实战案例（必须掌握）

📌 求数组最大值

package main

import "fmt"

func max(nums ...int) int {
	if len(nums) == 0 {
		return 0
	}
	maxVal := nums[0]
	for _, v := range nums {
		if v > maxVal {
			maxVal = v
		}
	}
	return maxVal
}
func main() {
	fmt.Println(max())
	fmt.Println(max(1))
	fmt.Println(max(1, 2))
	fmt.Println(max(1, 2, 3))
	fmt.Println(max(1, 2, 3, 4))
	fmt.Println(max(50, 66, 55, 77, 99, 65, 22, 35, 35, 69, 5, 65, 485, 548))
}

输出：

0
1
2
3
4
548

---

📌 封装计算逻辑

package main

import "fmt"

func calc(a, b int) (int, int, int, int) {
	return a + b, a - b, a * b, a / b
}
func main() {
	sum, sub, mul, div := calc(10, 2)
	fmt.Println("Sum:", sum)
	fmt.Println("Subtraction:", sub)
	fmt.Println("Multiplication:", mul)
	fmt.Println("Division:", div)
}

输出：

Sum: 12
Subtraction: 8
Multiplication: 20
Division: 5

---

小结（建议收藏⭐）

本文我们系统学习了 Go 函数的基础知识：

✅ 函数的定义与调用

✅ 参数写法（简写 / 多类型）

✅ 返回值（单返回 / 多返回）

✅ error 处理规范（开发必备）

✅ 命名返回值（面试重点）

✅ 可变参数 ... 的使用

---

🎯 最后说一句

函数看起来简单，但它是 Go 后续学习的基础：

• 接口（interface）
• 并发（goroutine）
• 中间件设计

👉 都会用到函数的高级特性

---