GO语言基础笔记（二）：控制结构与函数

1. 控制结构

1.1 if-else 结构

基本形式：if 条件判断后跟着一个代码块。如果条件为真，则执行该代码块。
else 语句：紧随 if 代码块后面，当 if 条件不成立时执行。
else if：可以在 if 和 else 之间添加更多的条件判断。

package mainimport ("fmt"
)func main() {score := 85 // 假设这是一个成绩// 使用 if 判断成绩是否优秀if score >= 90 {fmt.Println("成绩优秀，等级：A")} else if score >= 80 {// 当成绩不满足第一个 if 条件（即小于90），但满足 else if 条件时执行fmt.Println("成绩良好，等级：B")} else if score >= 70 {fmt.Println("成绩合格，等级：C")} else if score >= 60 {fmt.Println("成绩及格，等级：D")} else {// 当所有其他条件都不满足时执行 else 块fmt.Println("成绩不及格，等级：F")}
}

条件清晰：每个if和else if块的条件应该是互斥的，这样可以防止重复判断。
顺序安排：将最有可能发生的条件放在前面，可以提高代码效率。
避免嵌套过深：尽量减少if-else的嵌套深度，以保持代码的可读性。
条件简化：在条件判断中使用适当的逻辑运算符来简化表达式。

1.2 switch 结构

基本用法：switch 后跟一个表达式，然后是多个 case 分支。每个 case 后跟着要比较的值和执行的代码块。
不带表达式的 switch：可以直接在 case 后使用条件表达式。
fallthrough 关键字：默认情况下，每个 case 执行完后自动跳出 switch，使用 fallthrough 可以强制执行下一个 case。

package mainimport ("fmt"
)func main() {// 示例1：基本用法number := 3switch number {case 1:fmt.Println("数字是 1")case 2:fmt.Println("数字是 2")case 3:fmt.Println("数字是 3")default:fmt.Println("数字不是 1、2、3")}// 示例2：不带表达式的switchscore := 85switch {case score >= 90:fmt.Println("成绩优秀")case score >= 80:fmt.Println("成绩良好")case score >= 60:fmt.Println("成绩合格")default:fmt.Println("成绩不合格")}// 示例3：使用fallthroughmonth := 5switch month {case 3, 4, 5:fmt.Println("春季")fallthroughcase 6, 7, 8:fmt.Println("夏季")case 9, 10, 11:fmt.Println("秋季")case 12, 1, 2:fmt.Println("冬季")default:fmt.Println("未知的月份")}
}

明确case分支：每个case后面跟着一个或多个要比较的值和代码块。这使得代码逻辑清晰易懂。
使用default：当所有case都不匹配时，执行default分支。这是一个良好的编程习惯，可用于处理异常或未预期的情况。
不带表达式的switch：在某些情况下，不带表达式的switch可以替代多层嵌套的if-else，使得代码更加清晰。
谨慎使用fallthrough：fallthrough关键字使得控制流穿越到下一个case，即使下一个case的条件不成立也会执行。使用时要非常小心，以避免逻辑错误。

1.3 for 循环

基本结构：包括初始化语句、条件表达式和结束后的操作，格式为 for 初始化; 条件; 后续操作 {}。
条件循环：只有条件表达式的 for 循环。
无限循环：省略所有元素的 for 循环将无限循环直到内部有 break 或 return。

1. 基本的for循环

package mainimport ("fmt"
)func main() {// 示例1：基本的for循环for i := 0; i < 5; i++ {fmt.Println("基本循环，当前索引:", i)}
}

2. 条件循环

	// 示例2：条件循环j := 0for j < 5 {fmt.Println("条件循环，当前索引:", j)j++}

3. 无限循环

	// 示例3：无限循环k := 0for {if k == 3 {break // 当 k 等于 3 时退出循环}fmt.Println("无限循环，当前索引:", k)k++}
}

技巧性总结

明确循环条件：在编写for循环时，始终清晰地定义循环的开始和结束条件。
避免无限循环：在使用无限循环时，务必确保有一个明确的退出条件，以避免程序陷入死循环。
代码简洁：尽量保持循环体内代码的简洁，这有助于提高代码的可读性和可维护性。

2. 函数

2.1 函数定义

基本语法：func 函数名(参数列表) (返回值列表) { 函数体 }。
参数列表：定义输入的类型和名称。
返回值列表：可以是具名的也可以是非具名的，具名返回值在函数体开始时被自动初始化。

基本函数定义

package mainimport ("fmt"
)// 无参数，无返回值的函数
func greet() {fmt.Println("Hello, Go!")
}func main() {greet() // 调用函数
}

带参数的函数

// 带参数的函数
func add(x int, y int) int {return x + y
}func main() {result := add(5, 7) // 调用函数fmt.Println("结果:", result)
}

具名返回值

// 具名返回值
func swap(x, y string) (a, b string) {a = yb = xreturn // 隐式返回a, b
}func main() {a, b := swap("hello", "world")fmt.Println(a, b) // 输出：world hello
}
//使用具名返回值可以提高代码的可读性，尤其是在函数有多个返回值时。

非具名返回值

// 非具名返回值
func divide(x, y float64) (float64, error) {if y == 0.0 {return 0.0, fmt.Errorf("不能除以零")}return x / y, nil
}func main() {result, err := divide(10.0, 0.0)if err != nil {fmt.Println("错误:", err)} else {fmt.Println("结果:", result)}
}

清晰的参数和返回值：定义函数时，明确参数类型和返回值类型可以提高代码的可读性和健壮性。
合理使用具名返回值：在函数返回多个值或需要说明返回值意义时使用具名返回值。
错误处理：在可能出现错误的场合，返回一个错误值作为函数的一部分，以便于错误处理。

2.2 函数使用

调用函数：使用函数名和传入相应的参数。
返回值：可以返回一个或多个值。
匿名函数：没有函数名的函数，可以在定义后立即调用。

调用普通函数

package mainimport ("fmt"
)// 定义一个简单的相加函数
func add(x, y int) int {return x + y
}func main() {// 调用函数并处理返回值result := add(5, 7)fmt.Println("相加结果:", result)
}

处理多个返回值

// 定义一个函数，返回两个值
func divideAndRemainder(x, y int) (int, int) {return x / y, x % y
}func main() {// 接收两个返回值quotient, remainder := divideAndRemainder(7, 2)fmt.Println("商:", quotient, "余数:", remainder)
}

使用匿名函数

func main() {// 定义并立即调用匿名函数func(msg string) {fmt.Println(msg)}("Hello, Go!")
}

函数调用的准确性：在调用函数时，确保参数的正确性和返回值的正确处理。
处理多返回值：在函数返回多个值时，可以通过多个变量来接收这些值。
匿名函数的灵活性：匿名函数是一种灵活的工具，可以用于立即执行一些操作，或作为高阶函数的参数。

2.3回调函数

package mainimport ("fmt"
)// 定义回调函数类型，这种函数接受一个整数并返回一个整数
type callbackFunc func(int) int// processSlice 函数接受一个整数切片和一个回调函数
// 它对切片中的每个元素应用回调函数，并返回新的切片
func processSlice(slice []int, callback callbackFunc) []int {var result []intfor _, value := range slice {processedValue := callback(value)result = append(result, processedValue)}return result
}// 具体的回调函数，例如将整数乘以2
func multiplyByTwo(n int) int {return n * 2
}func main() {// 定义一个整数切片slice := []int{1, 2, 3, 4, 5}// 使用 multiplyByTwo 回调函数处理切片processedSlice := processSlice(slice, multiplyByTwo)// 打印原始和处理后的切片fmt.Println("原始切片:", slice)fmt.Println("处理后的切片:", processedSlice)
}

在这个示例中，我们定义了一个事件管理器eventManager，它允许注册回调函数并在事件触发时调用这些函数。

package mainimport ("fmt"
)// 定义回调函数类型
type eventCallback func()// 事件管理器
type eventManager struct {callbacks []eventCallback
}// 注册事件的回调函数
func (m *eventManager) registerCallback(callback eventCallback) {m.callbacks = append(m.callbacks, callback)
}// 触发事件，调用所有注册的回调函数
func (m *eventManager) triggerEvent() {for _, callback := range m.callbacks {callback()}
}func main() {// 创建事件管理器实例manager := eventManager{}// 注册一些回调函数manager.registerCallback(func() {fmt.Println("第一个事件回调被触发")})manager.registerCallback(func() {fmt.Println("第二个事件回调被触发")})// 触发事件manager.triggerEvent()
}