Go 语言基础

从零开始学习 Go 语言，掌握核心语法与编程思想

5 课时

Hello World

Go 是一门简洁、高效的编程语言。让我们从经典的 Hello World 开始。

每个 Go 程序都从 main 包的 main 函数开始执行。fmt 包提供了格式化输入输出的功能。

第一个 Go 程序

1package main
2 
3import "fmt"
4 
5func main() {
6    fmt.Println("Hello, World!")
7}

变量与类型

Go 是静态类型语言，每个变量都有明确的类型。Go 提供了多种声明变量的方式。

使用 var 关键字可以显式声明变量，也可以使用 := 短声明语法让编译器自动推断类型。

变量声明

1package main
2 
3import "fmt"
4 
5func main() {
6    // 显式类型声明
7    var name string = "Gopher"
8    var age int = 10
9    
10    // 类型推断
11    city := "Beijing"
12    
13    // 多变量声明
14    var x, y int = 1, 2
15    
16    // 常量
17    const Pi = 3.14159
18    
19    fmt.Println(name, age, city, x, y, Pi)
20}

基本数据类型

1// 数值类型
2var i int = 42
3var f float64 = 3.14
4var c complex128 = 1 + 2i
5 
6// 布尔类型
7var b bool = true
8 
9// 字符串
10var s string = "Hello"
11 
12// 类型转换
13var n float64 = float64(i)

控制流

Go 的控制流语句包括 if、for 和 switch。值得注意的是，Go 只有 for 循环，没有 while 循环。

if 语句可以在条件之前执行一个简短语句，该语句声明的变量作用域仅在 if 块内。

条件语句

1package main
2 
3import "fmt"
4 
5func main() {
6    x := 10
7    
8    // 基本 if
9    if x > 5 {
10        fmt.Println("x 大于 5")
11    }
12    
13    // if 带初始化语句
14    if y := x * 2; y > 15 {
15        fmt.Println("y 大于 15")
16    }
17    
18    // switch 语句
19    switch x {
20    case 1:
21        fmt.Println("一")
22    case 10:
23        fmt.Println("十")
24    default:
25        fmt.Println("其他")
26    }
27}

循环语句

1package main
2 
3import "fmt"
4 
5func main() {
6    // 标准 for 循环
7    for i := 0; i < 5; i++ {
8        fmt.Println(i)
9    }
10    
11    // while 风格
12    n := 0
13    for n < 5 {
14        n++
15    }
16    
17    // 无限循环
18    // for { }
19    
20    // range 遍历
21    nums := []int{1, 2, 3}
22    for i, v := range nums {
23        fmt.Println(i, v)
24    }
25}

函数

Go 的函数可以返回多个值，这是 Go 的一大特色。多返回值常用于返回结果和错误。

Go 支持闭包和匿名函数，函数是一等公民，可以作为参数传递。

函数定义

1package main
2 
3import "fmt"
4 
5// 基本函数
6func add(a, b int) int {
7    return a + b
8}
9 
10// 多返回值
11func divide(a, b float64) (float64, error) {
12    if b == 0 {
13        return 0, fmt.Errorf("除数不能为零")
14    }
15    return a / b, nil
16}
17 
18// 命名返回值
19func split(sum int) (x, y int) {
20    x = sum * 4 / 9
21    y = sum - x
22    return
23}
24 
25func main() {
26    fmt.Println(add(1, 2))
27    
28    result, err := divide(10, 2)
29    if err != nil {
30        fmt.Println(err)
31    }
32    fmt.Println(result)
33}

闭包与高阶函数

1package main
2 
3import "fmt"
4 
5// 返回一个闭包
6func counter() func() int {
7    count := 0
8    return func() int {
9        count++
10        return count
11    }
12}
13 
14// 函数作为参数
15func apply(nums []int, fn func(int) int) []int {
16    result := make([]int, len(nums))
17    for i, v := range nums {
18        result[i] = fn(v)
19    }
20    return result
21}
22 
23func main() {
24    c := counter()
25    fmt.Println(c()) // 1
26    fmt.Println(c()) // 2
27    
28    double := func(x int) int { return x * 2 }
29    nums := []int{1, 2, 3}
30    fmt.Println(apply(nums, double)) // [2, 4, 6]
31}

错误处理

Go 没有异常机制，而是通过返回 error 类型来处理错误。这种显式的错误处理方式使代码更加清晰。

error 是一个接口类型，只有一个 Error() 方法返回错误信息字符串。

错误处理模式

1package main
2 
3import (
4    "errors"
5    "fmt"
6)
7 
8// 定义错误
9var ErrNotFound = errors.New("not found")
10 
11func findUser(id int) (string, error) {
12    if id <= 0 {
13        return "", ErrNotFound
14    }
15    return "User", nil
16}
17 
18func main() {
19    user, err := findUser(0)
20    if err != nil {
21        if errors.Is(err, ErrNotFound) {
22            fmt.Println("用户不存在")
23        }
24        return
25    }
26    fmt.Println(user)
27}

自定义错误类型

1package main
2 
3import "fmt"
4 
5// 自定义错误类型
6type ValidationError struct {
7    Field   string
8    Message string
9}
10 
11func (e *ValidationError) Error() string {
12    return fmt.Sprintf("%s: %s", e.Field, e.Message)
13}
14 
15func validate(name string) error {
16    if name == "" {
17        return &ValidationError{
18            Field:   "name",
19            Message: "不能为空",
20        }
21    }
22    return nil
23}
24 
25func main() {
26    if err := validate(""); err != nil {
27        fmt.Println(err) // name: 不能为空
28    }
29}

下一章：数据结构

1package main 2 3import "fmt" 4 5func main() { 6 // 显式类型声明 7 var name string = "Gopher" 8 var age int = 10 9 10 // 类型推断 11 city := "Beijing" 12 13 // 多变量声明 14 var x, y int = 1, 2 15 16 // 常量 17 const Pi = 3.14159 18 19 fmt.Println(name, age, city, x, y, Pi) 20}

1// 数值类型 2var i int = 42 3var f float64 = 3.14 4var c complex128 = 1 + 2i 5 6// 布尔类型 7var b bool = true 8 9// 字符串 10var s string = "Hello" 11 12// 类型转换 13var n float64 = float64(i)

1package main 2 3import "fmt" 4 5func main() { 6 x := 10 7 8 // 基本 if 9 if x > 5 { 10 fmt.Println("x 大于 5") 11 } 12 13 // if 带初始化语句 14 if y := x * 2; y > 15 { 15 fmt.Println("y 大于 15") 16 } 17 18 // switch 语句 19 switch x { 20 case 1: 21 fmt.Println("一") 22 case 10: 23 fmt.Println("十") 24 default: 25 fmt.Println("其他") 26 } 27}

1package main 2 3import "fmt" 4 5func main() { 6 // 标准 for 循环 7 for i := 0; i < 5; i++ { 8 fmt.Println(i) 9 } 10 11 // while 风格 12 n := 0 13 for n < 5 { 14 n++ 15 } 16 17 // 无限循环 18 // for { } 19 20 // range 遍历 21 nums := []int{1, 2, 3} 22 for i, v := range nums { 23 fmt.Println(i, v) 24 } 25}

1package main 2 3import "fmt" 4 5// 基本函数 6func add(a, b int) int { 7 return a + b 8} 9 10// 多返回值 11func divide(a, b float64) (float64, error) { 12 if b == 0 { 13 return 0, fmt.Errorf("除数不能为零") 14 } 15 return a / b, nil 16} 17 18// 命名返回值 19func split(sum int) (x, y int) { 20 x = sum * 4 / 9 21 y = sum - x 22 return 23} 24 25func main() { 26 fmt.Println(add(1, 2)) 27 28 result, err := divide(10, 2) 29 if err != nil { 30 fmt.Println(err) 31 } 32 fmt.Println(result) 33}

1package main 2 3import "fmt" 4 5// 返回一个闭包 6func counter() func() int { 7 count := 0 8 return func() int { 9 count++ 10 return count 11 } 12} 13 14// 函数作为参数 15func apply(nums []int, fn func(int) int) []int { 16 result := make([]int, len(nums)) 17 for i, v := range nums { 18 result[i] = fn(v) 19 } 20 return result 21} 22 23func main() { 24 c := counter() 25 fmt.Println(c()) // 1 26 fmt.Println(c()) // 2 27 28 double := func(x int) int { return x * 2 } 29 nums := []int{1, 2, 3} 30 fmt.Println(apply(nums, double)) // [2, 4, 6] 31}

1package main 2 3import ( 4 "errors" 5 "fmt" 6) 7 8// 定义错误 9var ErrNotFound = errors.New("not found") 10 11func findUser(id int) (string, error) { 12 if id <= 0 { 13 return "", ErrNotFound 14 } 15 return "User", nil 16} 17 18func main() { 19 user, err := findUser(0) 20 if err != nil { 21 if errors.Is(err, ErrNotFound) { 22 fmt.Println("用户不存在") 23 } 24 return 25 } 26 fmt.Println(user) 27}

1package main 2 3import "fmt" 4 5// 自定义错误类型 6type ValidationError struct { 7 Field string 8 Message string 9} 10 11func (e *ValidationError) Error() string { 12 return fmt.Sprintf("%s: %s", e.Field, e.Message) 13} 14 15func validate(name string) error { 16 if name == "" { 17 return &ValidationError{ 18 Field: "name", 19 Message: "不能为空", 20 } 21 } 22 return nil 23} 24 25func main() { 26 if err := validate(""); err != nil { 27 fmt.Println(err) // name: 不能为空 28 } 29}