Go语言基础

1. Go语言的基本语法

Go语言的语法简洁直观，常见的编程概念都能够轻松实现。首先来看Go语言中的基本构建块：变量、常量、函数和控制结构。

1.1 变量声明与初始化

在Go中，变量可以通过关键字 var 来声明，也可以使用简短声明符 := 来直接初始化。

package main
import "fmt"
func main() {
    // 使用 var 声明并初始化变量
    var a int = 10
    var b = 20 // Go会自动推导类型
    fmt.Println("a =", a, "b =", b)
    // 使用简短声明符
    c := 30
    fmt.Println("c =", c)
}
​

解释

• var a int = 10：显式声明变量 a 类型为 int 并初始化为 10。

• var b = 20：Go自动推导类型，b 的类型为 int。

• c := 30：简短声明语法，Go自动推导 c 为 int。

1.2 常量声明

Go语言中的常量使用 const 关键字声明，并且一旦赋值后不可更改。

package main
import "fmt"
const Pi = 3.14
func main() {
    fmt.Println("Pi =", Pi)
}
​

解释

• const Pi = 3.14：声明常量 Pi，并初始化为 3.14。

1.3 基本控制结构

Go语言支持常见的控制结构，如 if、for、switch 等。

package main
import "fmt"
func main() {
    // if 语句
    x := 10
    if x > 5 {
        fmt.Println("x 大于 5")
    }
    // for 语句（Go没有while循环）
    for i := 0; i < 5; i++ {
        fmt.Println(i)
    }
    // switch 语句
    switch x {
    case 10:
        fmt.Println("x 是 10")
    default:
        fmt.Println("x 不是 10")
    }
}
​

解释

• if x > 5：如果 x 大于5，输出相应信息。

• for i := 0; i < 5; i++：Go中唯一的循环结构是 for，它可以用于实现 while、for 等多种循环。

• switch x：根据 x 的值执行相应的分支。

2. 数据类型与数组

Go语言提供了多种数据类型，包括整数、浮点数、布尔值、字符串等。数组和切片是Go语言中常用的数据结构。

2.1 数组与切片

Go中的数组是固定长度的，而切片（slice）是可动态扩展的数组。

package main
import "fmt"
func main() {
    // 数组声明与初始化
    var arr [5]int = [5]int{1, 2, 3, 4, 5}
    fmt.Println("数组:", arr)
    // 切片声明与初始化
    slice := []int{10, 20, 30, 40}
    fmt.Println("切片:", slice)
    // 切片的扩展
    slice = append(slice, 50)
    fmt.Println("扩展后的切片:", slice)
}
​

解释

• var arr [5]int：声明一个长度为5的数组。

• slice := []int{10, 20, 30, 40}：声明并初始化一个切片。

• append(slice, 50)：向切片追加元素，切片会动态扩展。

2.2 Map（字典）

Go中的map是无序的键值对集合，类似于其他语言中的字典。

package main
import "fmt"
func main() {
    // 创建并初始化一个map
    m := map[string]int{"Alice": 30, "Bob": 25}
    fmt.Println("Map:", m)
    // 向map添加元素
    m["Charlie"] = 35
    fmt.Println("更新后的Map:", m)
    // 检查map中是否存在某个键
    age, exists := m["Bob"]
    fmt.Println("Bob的年龄:", age, "存在:", exists)
}
​

解释

• map[string]int{"Alice": 30, "Bob": 25}：创建一个map，键是字符串类型，值是整型。

• m["Charlie"] = 35：向map中添加一个新的键值对。

• age, exists := m["Bob"]：检查map中是否存在键 Bob，如果存在则返回值及存在标志。

3. 函数与方法

Go语言支持函数和方法的定义。函数是独立的，而方法是与类型相关联的函数。

3.1 函数定义

package main
import "fmt"
// 函数定义
func add(a int, b int) int {
    return a + b
}
func main() {
    result := add(10, 20)
    fmt.Println("结果:", result)
}
​

解释

• func add(a int, b int) int：定义一个接受两个整数参数并返回一个整数的函数。

• add(10, 20)：调用函数并输出结果。

3.2 方法定义

方法与函数类似，但方法是附加在类型上的。

package main
import "fmt"
type Circle struct {
    radius float64
}
// 定义一个方法
func (c Circle) area() float64 {
    return 3.14 * c.radius * c.radius
}
func main() {
    circle := Circle{radius: 5}
    fmt.Println("圆的面积:", circle.area())
}
​

解释

• func (c Circle) area()：area 是 Circle 类型的方法，c 是方法接收者。

4. 并发编程：goroutine与channel

Go语言最强大的特性之一是内置的并发支持。Go通过goroutine和channel来实现并发操作。

4.1 Goroutine

Goroutine是Go语言中的轻量级线程，启动时非常高效。

package main
import "fmt"
import "time"
func printMessage(msg string) {
    fmt.Println(msg)
}
func main() {
    // 启动一个goroutine
    go printMessage("Hello from Goroutine!")
    time.Sleep(time.Second)  // 等待goroutine执行
}
​

解释

• go printMessage("Hello from Goroutine!")：启动一个goroutine来执行 printMessage 函数。

• time.Sleep(time.Second)：为了让主线程等待goroutine执行结束。

4.2 Channel

Channel是用于goroutine之间通信的管道。

package main
import "fmt"
func sendData(ch chan string) {
    ch <- "Hello from Channel!"
}
func main() {
    ch := make(chan string)
    go sendData(ch)
    msg := <-ch
    fmt.Println(msg)
}
​

解释

• ch := make(chan string)：创建一个字符串类型的channel。

• ch <- "Hello from Channel!"：通过channel发送数据。

• msg := <-ch：接收channel中的数据。

5. 错误处理

Go语言的错误处理使用内建的 error 类型，而不像其他语言使用异常机制。

package main
import "fmt"
import "errors"
func divide(a, b int) (int, error) {
    if b == 0 {
        return 0, errors.New("除数不能为零")
    }
    return a / b, nil
}
func main() {
    result, err := divide(10, 0)
    if err != nil {
        fmt.Println("错误:", err)
    } else {
        fmt.Println("结果:", result)
    }
}
​

解释

• if b == 0：判断除数是否为零，若为零则返回错误。

• errors.New("除数不能为零")：创建一个错误。