Go语言学习系列——基本函数定义与调用——【坚果派

1、基本函数定义与调用

package main

import "fmt"

// 1. 基本函数定义
func sayHello(name string) {
	fmt.Printf("你好, %s!\n", name)
}

// 2. 带返回值的函数
func add(a, b int) int {
	return a + b
}

// 3. 多返回值函数
func divide(a, b float64) (float64, error) {
	if b == 0 {
		return 0, fmt.Errorf("除数不能为0")
	}
	return a / b, nil
}

// 4. 命名返回值
func rectangle(width, height float64) (area, perimeter float64) {
	area = width * height
	perimeter = 2 * (width + height)
	return // 隐式返回命名的返回值
}

func main() {
	// 函数调用示例
	sayHello("张三")

	result := add(5, 3)
	fmt.Printf("5 + 3 = %d\n", result)

	if quotient, err := divide(10, 2); err != nil {
		fmt.Println("错误:", err)
	} else {
		fmt.Printf("10 / 2 = %.2f\n", quotient)
	}

	area, peri := rectangle(4, 5)
	fmt.Printf("矩形面积: %.2f, 周长: %.2f\n", area, peri)
}

2、函数作用域与变量

package main

import "fmt"

// 全局变量
var globalVar = "全局变量"

func main() {
	// 局部变量
	localVar := "局部变量"

	fmt.Println("在main中访问:", globalVar)
	fmt.Println("在main中访问:", localVar)

	// 演示变量作用域
	scopeDemo()

	// 闭包示例
	counter := createCounter()
	fmt.Println(counter()) // 输出: 1
	fmt.Println(counter()) // 输出: 2
	fmt.Println(counter()) // 输出: 3
}

func scopeDemo() {
	fmt.Println("在scopeDemo中访问:", globalVar)
	// fmt.Println(localVar) // 错误：无法访问main的局部变量
}

// 闭包函数
func createCounter() func() int {
	count := 0
	return func() int {
		count++
		return count
	}
}

3、递归函数示例

package main

import "fmt"

// 1. 阶乘计算
func factorial(n int) int {
	if n <= 1 {
		return 1
	}
	return n * factorial(n-1)
}

// 2. 斐波那契数列
func fibonacci(n int) int {
	if n <= 1 {
		return n
	}
	return fibonacci(n-1) + fibonacci(n-2)
}

// 3. 目录遍历示例
type TreeNode struct {
	Value int
	Left  *TreeNode
	Right *TreeNode
}

func traverseTree(node *TreeNode) {
	if node == nil {
		return
	}
	fmt.Printf("%d ", node.Value)
	traverseTree(node.Left)
	traverseTree(node.Right)
}

func main() {
	// 测试阶乘
	fmt.Println("5的阶乘:", factorial(5))

	// 测试斐波那契
	fmt.Println("\n斐波那契数列前10个数:")
	for i := 0; i < 10; i++ {
		fmt.Printf("%d ", fibonacci(i))
	}

	// 测试树遍历
	fmt.Println("\n\n二叉树遍历:")
	root := &TreeNode{
		Value: 1,
		Left: &TreeNode{
			Value: 2,
			Left:  &TreeNode{Value: 4},
			Right: &TreeNode{Value: 5},
		},
		Right: &TreeNode{
			Value: 3,
			Left:  &TreeNode{Value: 6},
			Right: &TreeNode{Value: 7},
		},
	}
	traverseTree(root)

	fmt.Println("\n\n按回车键退出...")
	fmt.Scanln()
}

总结

1. 函数定义规则：

• 使用func关键字
• 函数名遵循可见性规则
• 参数列表可以为空
• 返回值类型可以省略
• 支持多返回值

2. 参数传递：

• 值传递：参数为副本
• 指针传递：可修改原值
• 可变参数：func(args ...type)

3. 作用域规则：

• 全局变量：包级别可见
• 局部变量：函数内可见
• 块级作用域：{}内可见

4. 闭包特点：

• 可以访问外部变量
• 保持外部变量状态
• 常用于回调函数
• 实现数据封装

5. 递归注意事项：

• 必须有终止条件
• 注意栈溢出风险
• 考虑性能影响
• 可以用循环优化

6. 最佳实践：

1. 函数设计：
   • 单一职责
   • 适当长度
   • 清晰的参数和返回值
   • 良好的错误处理
2. 变量作用域：
   • 最小作用域原则
   • 避免全局变量
   • 合理使用包级变量
3. 递归使用：
   • 适合树形结构
   • 考虑性能要求
   • 提供非递归替代方案