if 条件判断后跟着一个代码块。如果条件为真，则执行该代码块。if 代码块后面，当 if 条件不成立时执行。if 和 else 之间添加更多的条件判断。package main
import (
"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的嵌套深度，以保持代码的可读性。- 条件简化：在条件判断中使用适当的逻辑运算符来简化表达式。
switch 后跟一个表达式，然后是多个 case 分支。每个 case 后跟着要比较的值和执行的代码块。case 后使用条件表达式。case 执行完后自动跳出 switch，使用 fallthrough 可以强制执行下一个 case。?
package main
import (
"fmt"
)
func main() {
// 示例1：基本用法
number := 3
switch number {
case 1:
fmt.Println("数字是 1")
case 2:
fmt.Println("数字是 2")
case 3:
fmt.Println("数字是 3")
default:
fmt.Println("数字不是 1、2、3")
}
// 示例2：不带表达式的switch
score := 85
switch {
case score >= 90:
fmt.Println("成绩优秀")
case score >= 80:
fmt.Println("成绩良好")
case score >= 60:
fmt.Println("成绩合格")
default:
fmt.Println("成绩不合格")
}
// 示例3：使用fallthrough
month := 5
switch month {
case 3, 4, 5:
fmt.Println("春季")
fallthrough
case 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的条件不成立也会执行。使用时要非常小心，以避免逻辑错误。
for 初始化; 条件; 后续操作 {}。for 循环。for 循环将无限循环直到内部有 break 或 return。????????1. 基本的for循环
package main
import (
"fmt"
)
func main() {
// 示例1：基本的for循环
for i := 0; i < 5; i++ {
fmt.Println("基本循环，当前索引:", i)
}
}
?????????2. 条件循环
// 示例2：条件循环
j := 0
for j < 5 {
fmt.Println("条件循环，当前索引:", j)
j++
}
????????3. 无限循环?
// 示例3：无限循环
k := 0
for {
if k == 3 {
break // 当 k 等于 3 时退出循环
}
fmt.Println("无限循环，当前索引:", k)
k++
}
}
技巧性总结
- 明确循环条件：在编写
for循环时，始终清晰地定义循环的开始和结束条件。- 避免无限循环：在使用无限循环时，务必确保有一个明确的退出条件，以避免程序陷入死循环。
- 代码简洁：尽量保持循环体内代码的简洁，这有助于提高代码的可读性和可维护性。
func 函数名(参数列表) (返回值列表) { 函数体 }。package main
import (
"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 = y
b = x
return // 隐式返回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)
}
}
- 清晰的参数和返回值：定义函数时，明确参数类型和返回值类型可以提高代码的可读性和健壮性。
- 合理使用具名返回值：在函数返回多个值或需要说明返回值意义时使用具名返回值。
- 错误处理：在可能出现错误的场合，返回一个错误值作为函数的一部分，以便于错误处理。
package main
import (
"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!")
}
package main
import (
"fmt"
)
// 定义回调函数类型，这种函数接受一个整数并返回一个整数
type callbackFunc func(int) int
// processSlice 函数接受一个整数切片和一个回调函数
// 它对切片中的每个元素应用回调函数，并返回新的切片
func processSlice(slice []int, callback callbackFunc) []int {
var result []int
for _, 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 main
import (
"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()
}
?
多返回值：Go函数可以返回多个值，这在错误处理和数据返回方面非常有用。
命名返回值：函数可以有命名的返回值，这些返回值在函数开始时就被声明，可以在函数体内直接使用。
变参函数（Variadic Functions）：Go支持变参函数，允许函数接受任意数量的参数。
匿名函数和闭包（Closures）：Go支持匿名函数，这些函数可以定义在其他函数内部，并可以访问外部函数的变量，形成闭包。
延迟调用（Defer）：Go的defer语句会延迟函数的执行直到包含它的函数结束。
高阶函数（Higher-Order Functions）：在Go中，函数可以作为参数传递给其他函数，也可以作为其他函数的返回值。
方法（Methods）：Go允许定义在结构体（或任意类型）上的函数，称为方法。这提供了一种面向对象的方式来处理数据。
接口（Interfaces）：虽然不是直接的函数机制，但接口在Go中用于定义函数的行为契约，为多态和模块化设计提供支持。
递归函数（Recursive Functions）：函数可以调用自身，这是在处理某些算法时非常有用的。
并发的函数调用（Goroutines）：通过goroutines，Go支持在轻量级线程中并发执行函数。
?