Skip to main content

Go

Site​

  1. Go 语言中文文档
  2. Golang 新手可能会踩的 58 个坑
  3. https://golangguide.top/golang/%E5%AD%A6%E4%B9%A0%E8%B7%AF%E7%BA%BF.html
  4. https://www.gin-vue-admin.com/guide/server/core/viper.html
  5. https://github.com/spf13/viper

特性​

Go（Golang）是一门简洁、高效且独具特色的编程语言，它在语法和设计上与许多其他编程语言有所不同。以下是一些 Go 中的独特使用技巧或特性，这些特性在其他语言中可能不常见或以不同方式实现：

1. 命名返回值​

Go 支持在函数声明中为返回值命名，这在其他语言中比较少见。命名返回值可以让代码更清晰，也可以在函数中直接使用这些命名变量。

示例：

func calculate(a, b int) (sum int, product int) {
    sum = a + b
    product = a * b
    return // 直接返回，无需显式列出返回值
}

优点：

  • 减少显式定义局部变量的需求。
  • 提高代码可读性，特别是函数有多个返回值时。

注意：

  • 不过滥用命名返回值可能会导致代码难以维护，尤其是函数体较长时。

2. 多返回值​

Go 原生支持多个返回值，而不需要像其他语言（如 Java 或 Python）那样使用元组或对象包装。

示例：

func divide(a, b int) (int, error) {
    if b == 0 {
        return 0, fmt.Errorf("division by zero")
    }
    return a / b, nil
}

result, err := divide(10, 2)
if err != nil {
    fmt.Println("Error:", err)
} else {
    fmt.Println("Result:", result)
}

应用场景：

  • 常用于返回结果和错误（result, err 的模式在 Go 中非常常见）。
  • 避免了使用异常（exceptions）作为错误处理机制。

3. defer 关键字​

defer 用于延迟函数的执行，通常用于资源清理（如关闭文件、解锁等）。它的执行顺序是 后进先出（LIFO）。

示例：

func example() {
    defer fmt.Println("world")
    fmt.Println("hello")
}
// 输出：
// hello
// world

资源清理示例：

func readFile(filename string) {
    file, err := os.Open(filename)
    if err != nil {
        log.Fatal(err)
    }
    defer file.Close() // 确保文件在函数退出时被关闭

    // 读取文件内容
}

注意：

  • defer 的调用是在函数返回之后、退出之前执行。

4. 简短变量声明（:=）​

Go 提供了一种简洁的变量声明方式 :=，可以在函数内快速声明并初始化变量。

示例：

func main() {
    x := 10 // 等价于 var x int = 10
    y := "hello"
    fmt.Println(x, y)
}

注意：

  • := 只能用于函数内部，不能用于全局变量。
  • 如果变量已经声明，则 := 不会重新声明，而是更新已有变量的值。

5. 接口（interface）的隐式实现​

Go 的接口是隐式实现的，不需要显式声明“实现了某个接口”。只要一个类型实现了接口中定义的所有方法，就认为它实现了该接口。

示例：

type Speaker interface {
    Speak() string
}

type Dog struct{}

func (d Dog) Speak() string {
    return "Woof!"
}

func main() {
    var s Speaker = Dog{} // Dog 隐式实现了 Speaker
    fmt.Println(s.Speak()) // 输出：Woof!
}

优点：

  • 减少了模板代码（boilerplate code）。
  • 提高了灵活性和解耦性。

6. 零值（Zero Value）​

Go 中的变量在声明时会自动初始化为“零值”，即使没有显式赋值。常见的零值如下：

  • 数字类型：0
  • 字符串类型：""
  • 布尔类型：false
  • 指针、切片、映射、通道、接口：nil

示例：

var x int    // x 的初始值为 0
var s string // s 的初始值为 ""
var b bool   // b 的初始值为 false

注意：

  • 零值的存在避免了未初始化变量的错误，但同时也要求开发者清楚零值的含义。

7. 切片（Slice）与数组的区别​

Go 中的切片（slice）是比数组更强大的数据结构，它是对底层数组的引用，可以动态调整大小。

切片示例：

func main() {
    arr := [5]int{1, 2, 3, 4, 5} // 数组
    slice := arr[1:4]            // 切片，引用了数组的一部分
    fmt.Println(slice)           // 输出：[2 3 4]
}

切片的特点：

  • 切片是动态的，可以扩展或缩小。
  • 切片是引用类型，多个切片可以共享同一个底层数组。

8. 内置并发支持（goroutine 和 channel）​

Go 原生支持并发编程，通过 goroutine 和 channel 实现。

Goroutine 示例：

func say(s string) {
    for i := 0; i < 5; i++ {
        fmt.Println(s)
    }
}

func main() {
    go say("world") // 启动一个新的 goroutine
    say("hello")
}

Channel 示例：

func sum(a, b int, ch chan int) {
    ch <- a + b // 将结果发送到 channel
}

func main() {
    ch := make(chan int)
    go sum(3, 4, ch)
    result := <-ch // 从 channel 接收结果
    fmt.Println(result) // 输出：7
}

特点：

  • goroutine 是轻量级线程，启动成本很低。
  • channel 用于 goroutine 间的通信，避免了显式锁的使用。

9. 错误处理​

Go 不使用异常（exceptions）作为主要的错误处理机制，而是通过显式返回错误值来处理。

示例：

func divide(a, b int) (int, error) {
    if b == 0 {
        return 0, fmt.Errorf("division by zero")
    }
    return a / b, nil
}

func main() {
    result, err := divide(10, 0)
    if err != nil {
        fmt.Println("Error:", err)
    } else {
        fmt.Println("Result:", result)
    }
}

特点：

  • 错误处理显式、清晰。
  • 通过 panic 和 recover 机制处理不可恢复的错误。

10. 空白标识符（_）​

Go 使用空白标识符 _ 来忽略不需要的值（如函数的返回值）。

示例：

func returnTwoValues() (int, int) {
    return 1, 2
}

func main() {
    a, _ := returnTwoValues() // 忽略第二个返回值
    fmt.Println(a)            // 输出：1
}

特点：

  • 避免了未使用变量的编译错误。
  • 常用于忽略函数的多返回值。

11. 无隐式类型提升​

Go 不会自动将一种类型提升为另一种类型（例如 int 和 float64 之间）。需要显式转换。

示例：

var x int = 10
var y float64 = 2.5
z := float64(x) + y // 必须显式转换
fmt.Println(z)

12. 严格的代码风格​

Go 强制使用 gofmt 工具来格式化代码，这确保了所有 Go 代码都有一致的风格。

这些特性和技巧使 Go 成为一门独特的编程语言，特别适合构建高性能、并发的系统。

if switch​

在 Go 中，if 和 switch 语法也有一些独特的用法和特性，与其他语言（如 C、Java 或 Python）相比显得更简洁、灵活。以下是 Go 中 if 和 switch 的特性和使用技巧：

1. if 语句的特点​

1.1 支持在条件中声明变量​

Go 的 if 语句允许在条件判断中声明和初始化变量，这些变量的作用域仅限于 if 块及其相关的 else 块中。

示例：

if x := 10; x > 5 {
    fmt.Println("x is greater than 5")
} else {
    fmt.Println("x is less than or equal to 5")
}
// x 在这里是不可访问的

特点：

  • 这种写法可以减少变量的作用域，避免污染外部作用域。
  • 初始化的变量仅在 if 和 else 块中可用。

1.2 不需要括号​

Go 中的 if 条件判断不需要像 C 或 Java 那样用括号 () 包裹条件表达式。

示例：

if x > 5 {
    fmt.Println("x is greater than 5")
}

特点：

  • 代码更加简洁。
  • 强制使用花括号 {}，即使只有一行代码（避免隐式的代码块问题）。

1.3 没有三元操作符​

Go 中没有像 C 或 Python 那样的三元操作符（condition ? trueValue : falseValue）。类似的功能可以通过 if-else 实现。

示例：

// 没有三元操作符，需使用 if-else
x := 10
y := 20
max := 0
if x > y {
    max = x
} else {
    max = y
}
fmt.Println("Max:", max)

2. switch 语句的特点​

2.1 不需要显式的 break​

Go 中的 switch 语句默认会在匹配到某个 case 后自动退出，无需显式使用 break。这与 C 或 Java 的 switch 不同，避免了忘记写 break 导致的错误。

示例：

switch x := 2; x {
case 1:
    fmt.Println("x is 1")
case 2:
    fmt.Println("x is 2")
case 3:
    fmt.Println("x is 3")
default:
    fmt.Println("x is unknown")
}

特点：

  • 自动退出特性使得代码更安全、清晰。
  • 如果需要继续执行下一个 case，可以使用 fallthrough 关键字。

2.2 可选的初始化语句​

和 if 类似，switch 也支持在条件判断前声明和初始化变量。

示例：

switch x := 10; {
case x < 5:
    fmt.Println("x is less than 5")
case x >= 5 && x < 15:
    fmt.Println("x is between 5 and 15")
default:
    fmt.Println("x is 15 or more")
}

特点：

  • 初始化的变量作用域仅限于 switch 块。
  • 可以结合条件表达式使用。

2.3 支持表达式​

Go 的 switch 语句支持任意的表达式，而不仅仅是常量或整数。

示例：

switch x := 10; {
case x%2 == 0:
    fmt.Println("x is even")
case x%2 != 0:
    fmt.Println("x is odd")
}

特点：

  • 灵活性更高，支持布尔表达式、范围判断等。

2.4 fallthrough 关键字​

Go 中的 switch 默认不会“贯穿”（fall-through）到下一个 case，但如果确实需要这种行为，可以使用 fallthrough 关键字。

示例：

switch x := 1; x {
case 1:
    fmt.Println("x is 1")
    fallthrough
case 2:
    fmt.Println("x is 2 or fallthrough from 1")
default:
    fmt.Println("x is something else")
}

输出：

x is 1
x is 2 or fallthrough from 1

注意：

  • fallthrough 不会检查下一个 case 的条件，直接执行下一个 case 的代码块。
  • 它通常用于特定场景，滥用可能会降低代码可读性。

2.5 支持多值匹配​

Go 的 switch 语句支持在一个 case 中匹配多个值。

示例：

switch day := "Saturday"; day {
case "Monday", "Tuesday", "Wednesday", "Thursday", "Friday":
    fmt.Println("It's a weekday")
case "Saturday", "Sunday":
    fmt.Println("It's the weekend")
default:
    fmt.Println("Unknown day")
}

特点：

  • 使用逗号分隔多个值，简化代码。

2.6 switch 可以不带表达式​

Go 的 switch 语句允许省略表达式，这种情况下等价于 switch true，常用于替代多层嵌套的 if-else。

示例：

x := 10
switch {
case x < 5:
    fmt.Println("x is less than 5")
case x >= 5 && x < 15:
    fmt.Println("x is between 5 and 15")
default:
    fmt.Println("x is 15 or more")
}

特点：

  • 更加灵活，可以处理复杂的条件逻辑。
  • 提高代码可读性，避免多层 if-else 嵌套。

3. 结合 type 的 switch（类型断言）​

Go 的 switch 语句支持基于类型的分支逻辑，常用于接口值的类型断言。

示例：

func typeSwitch(i interface{}) {
    switch v := i.(type) {
    case int:
        fmt.Println("i is an int:", v)
    case string:
        fmt.Println("i is a string:", v)
    case bool:
        fmt.Println("i is a bool:", v)
    default:
        fmt.Println("i is of unknown type")
    }
}

func main() {
    typeSwitch(42)
    typeSwitch("hello")
    typeSwitch(true)
}

特点：

  • 使用 .(type) 语法进行类型断言。
  • 常用于处理接口值的多种可能类型。

总结​

if 的独特之处：​

  1. 支持在条件中声明变量。
  2. 不需要括号包裹条件表达式。
  3. 没有三元操作符，需用 if-else 实现。

switch 的独特之处：​

  1. 默认不需要 break，更安全。
  2. 支持初始化语句。
  3. 支持表达式和范围判断。
  4. 支持多值匹配。
  5. 可以省略表达式，替代多层 if-else。
  6. 支持类型断言（type switch）。
  7. 使用 fallthrough 实现贯穿行为（但不常用）。

Go 的 if 和 switch 设计强调简洁性和安全性，避免了许多其他语言中容易出现的错误，同时提供了更灵活的语法，适合处理各种场景。