Go语言入门教程 – wiki基地

作者： /

Go语言入门教程

I. Go语言简介

A. 什么是Go？
Go（或Golang）是由Google开发的一种开源编程语言，于2009年首次发布。它旨在提高开发人员的生产力，尤其是在处理大规模、高并发的系统时。Go语言融合了C语言的效率、Python的开发速度以及内置的并发支持。

Go语言的主要特点：
* 并发性（Concurrency）：通过Goroutines和Channels提供轻量级并发机制。
* 垃圾回收（Garbage Collection）：自动内存管理，减少开发人员的心智负担。
* 静态类型（Static Typing）：在编译时进行类型检查，有助于捕获错误并提高代码可靠性。
* 快速编译：Go的编译器速度极快，使得开发迭代周期缩短。
* 简洁性：语法简洁明了，易于学习和阅读。
* 强大的标准库：提供了丰富的内置包，涵盖网络、文件I/O、加密等诸多领域。

B. 为什么要学习Go？
* 高性能：Go程序编译为机器码，执行效率高。
* 简单易学：语法规则少，上手快。
* 强大的生态系统：拥有活跃的社区和丰富的第三方库。
* 广泛的应用场景：被广泛应用于网络服务、微服务、云计算、命令行工具等领域。许多知名公司（如Google、Uber、Dropbox）都在使用Go。

C. 环境搭建
1. 安装Go：
访问Go官方网站下载适用于您操作系统的安装包。按照安装向导的指示完成安装。
2. 验证安装：
打开命令行工具（如CMD、PowerShell或Terminal），输入 go version。如果显示Go的版本信息，则表示安装成功。
3. GOPATH 和 Go Modules：
* GOPATH (旧方式)：Go 1.11之前，所有Go项目都必须放在GOPATH目录下。现在，Go Modules已成为主流。
* Go Modules (推荐)：Go 1.11及以后版本引入，是官方推荐的依赖管理方式。它允许您在文件系统的任何位置创建项目，并管理项目的依赖。

  1. 您的第一个 “Hello, World!” 程序：
    在您的项目目录下创建一个名为 main.go 的文件，并写入以下代码：

    “`go
    package main // 声明主包，可执行程序必须包含main包

    import “fmt” // 导入fmt包，用于格式化输入输出

    func main() { // main函数是程序的入口点
    fmt.Println(“Hello, World!”) // 打印字符串到控制台
    }
    “`

    保存文件，然后在命令行中导航到该文件所在目录，运行：go run main.go。
    您将看到输出 Hello, World!。

II. Go语言基础

A. 变量与数据类型
1. 变量声明：
* 使用 var 关键字：
go
var name string = "Go语言"
var age int
age = 15
* 使用 := 短变量声明（只能在函数内部使用）：
go
message := "学习Go很有趣！"
score := 100
* 批量声明：
go
var (
a string = "Apple"
b int = 10
)
2. 基本类型：
* 整型：int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64, uintptr (无符号整型)。
* 浮点型：float32, float64。
* 布尔型：bool (值为 true 或 false)。
* 字符串：string (UTF-8编码)。

  1. 类型转换：Go是强类型语言，不同类型之间需要显式转换。
    go
    var i int = 42
    var f float64 = float64(i)
    var u uint = uint(f)

  2. 常量：使用 const 关键字。
    go
    const Pi = 3.14159
    const Greeting = "Hello"

B. 运算符
Go语言支持常见的算术、关系、逻辑和位运算符。

  1. 算术运算符：+, -, *, /, %
  2. 关系运算符：==, !=, >, <, >=, <=
  3. 逻辑运算符：&& (AND), || (OR), ! (NOT)
  4. 位运算符：&, |, ^, <<, >>

C. 控制流
1. if-else 语句：
“`go
if score >= 60 {
fmt.Println(“及格”)
} else {
fmt.Println(“不及格”)
}

// 可以在if语句中包含一个简短的声明
if val := someFunction(); val > 0 {
    fmt.Println("值大于0")
} else {
    fmt.Println("值小于等于0")
}
```

  1. for 循环：Go只有 for 循环，但它可以模拟其他语言中的 while 和 do-while。

    • 基本 for 循环：
      go
      for i := 0; i < 5; i++ {
      fmt.Println(i)
      }
    • while 风格：
      go
      sum := 1
      for sum < 100 {
      sum += sum
      }
      fmt.Println(sum)
    • 无限循环：
      go
      for {
      // ...
      }
    • range 循环（用于遍历切片、数组、字符串、map、通道）：
      go
      numbers := []int{1, 2, 3}
      for index, value := range numbers {
      fmt.Printf("Index: %d, Value: %d\n", index, value)
      }

  2. switch 语句：
    “`go
    day := “Monday”
    switch day {
    case “Monday”, “Tuesday”:
    fmt.Println(“工作日”)
    case “Saturday”, “Sunday”:
    fmt.Println(“周末”)
    default:
    fmt.Println(“未知”)
    }

    // switch 语句可以没有条件表达式
    t := time.Now()
    switch {
    case t.Hour() < 12:
    fmt.Println(“上午”)
    default:
    fmt.Println(“下午”)
    }

    // fallthrough 关键字
    i := 0
    switch i {
    case 0:
    fmt.Println(“0”)
    fallthrough // 会执行下一个case
    case 1:
    fmt.Println(“1”)
    } // 输出：0 1
    “`

D. 函数
1. 定义函数：
“`go
func add(x int, y int) int { // 参数类型在变量名之后，返回值类型在参数列表之后
return x + y
}

func greet(name string) {
    fmt.Println("Hello, " + name)
}
```

  1. 多返回值：Go函数可以返回多个值。
    “`go
    func swap(x, y string) (string, string) {
    return y, x
    }

    a, b := swap(“hello”, “world”) // a=”world”, b=”hello”
    “`

  2. 命名返回值：
    go
    func split(sum int) (x, y int) { // x, y被命名，并作为返回值
    x = sum * 4 / 9
    y = sum - x
    return // 直接返回x和y的值
    }

  3. 可变参数（Variadic Functions）：
    “`go
    func sumAll(nums …int) int { // …int表示可变参数列表
    total := 0
    for _, num := range nums {
    total += num
    }
    return total
    }

    fmt.Println(sumAll(1, 2, 3, 4)) // 输出 10
    “`

  4. 匿名函数和闭包：
    “`go
    // 匿名函数
    func() {
    fmt.Println(“这是一个匿名函数”)
    }() // 立即执行

    // 闭包
    func makeMultiplier(factor int) func(int) int {
    return func(n int) int {
    return n * factor
    }
    }
    double := makeMultiplier(2)
    fmt.Println(double(5)) // 输出 10
    “`

E. 包（Packages）
Go程序由包组成，main包是可执行程序的入口。
1. 导入包：
go
import (
"fmt"
"math"
)

  1. 创建和使用自定义包：
    在项目目录下创建子目录 mymath，并在其中创建 mymath.go：
    “`go
    // mymath/mymath.go
    package mymath

    // Add 函数首字母大写表示它是导出的（公开的）
    func Add(a, b int) int {
    return a + b
    }
    在 `main.go` 中使用：go
    package main

    import (
    “fmt”
    “your_module_name/mymath” // 替换your_module_name为您的项目模块名
    )

    func main() {
    fmt.Println(mymath.Add(10, 20))
    }
    ``
    （注意：需要先初始化Go Module：    go mod init your_module_name`）

  2. 可见性规则：

    • 标识符（变量、函数、类型等）首字母大写表示它是导出的（Exported），可以在包外部访问。
    • 标识符首字母小写表示它是未导出的（Unexported），只能在当前包内部访问。

III. 数据结构

A. 数组（Arrays）
数组是具有相同数据类型且固定长度的序列。
“`go
var a [5]int // 声明一个包含5个整数的数组，默认值为0
b := [3]int{1, 2, 3} // 声明并初始化
c := […]int{4, 5, 6, 7} // 编译器自动推断数组长度

fmt.Println(b[0]) // 访问元素
b[1] = 20 // 修改元素
“`

B. 切片（Slices）
切片是Go中最常用的动态数组，它是一个引用类型。
1. 创建切片：
* 基于数组创建：
go
primes := [6]int{2, 3, 5, 7, 11, 13}
s := primes[1:4] // 从索引1到索引4（不包含4）
fmt.Println(s) // 输出 [3 5 7]
* 使用 make 函数：
go
s := make([]int, 5) // 创建一个长度为5，容量为5的切片
s2 := make([]int, 0, 10) // 创建一个长度为0，容量为10的切片
* 切片字面量：
go
s3 := []string{"a", "b", "c"}
2. append()，len()，cap()：
* len(s)：返回切片的长度。
* cap(s)：返回切片的容量（底层数组的长度）。
* append(s, elements...)：向切片追加元素，如果容量不足会重新分配底层数组。
go
var s []int
s = append(s, 1)
s = append(s, 2, 3, 4)

C. 映射（Maps）
Map是键值对的无序集合。
1. 声明与初始化：
* 使用 make：
go
m := make(map[string]int) // 键为string，值为int
* 字面量：
go
m2 := map[string]string{
"name": "Alice",
"city": "New York",
}
2. 添加、访问、删除：
go
m["age"] = 30 // 添加或修改
fmt.Println(m["name"]) // 访问
delete(m, "city") // 删除
3. 检查键是否存在：
go
val, ok := m["name"]
if ok {
fmt.Println("name存在，值为:", val)
} else {
fmt.Println("name不存在")
}

D. 结构体（Structs）
结构体是用户自定义的类型，用于组合不同类型的字段。
1. 定义结构体：
go
type Person struct {
Name string
Age int
City string
}
2. 创建和访问：
“`go
p1 := Person{“Bob”, 25, “London”} // 按字段顺序初始化
p2 := Person{Name: “Alice”, Age: 30} // 字段名:值 初始化，未赋值的字段为零值

fmt.Println(p1.Name) // 访问字段
p1.Age = 26          // 修改字段
```
  1. 匿名结构体：
    go
    anon := struct {
    X int
    Y int
    }{10, 20}
    fmt.Println(anon.X, anon.Y)

IV. 指针（Pointers）

A. 什么是指针？
指针存储变量的内存地址。Go语言中的指针不如C/C++中那么强大，但仍然很有用。
B. 声明与使用：
* & 运算符：获取变量的内存地址。
* * 运算符：访问指针指向的值（解引用）。

go
i := 42
p := &i // p现在指向i的内存地址
fmt.Println(*p) // 读取p指向的值，输出 42
*p = 21 // 通过p修改i的值
fmt.Println(i) // 输出 21

C. 何时使用指针？
* 当您需要修改函数外部的变量时（Go是值传递）。
* 传递大型数据结构时，可以避免复制整个结构体，提高效率。

V. 方法与接口

A. 方法（Methods）
Go语言中，方法是绑定到特定类型（通常是结构体）的函数。
1. 定义方法：
“`go
type Rectangle struct {
Width, Height float64
}

// 值接收者方法
func (r Rectangle) Area() float64 {
    return r.Width * r.Height
}

// 指针接收者方法
func (r *Rectangle) Scale(factor float64) {
    r.Width *= factor
    r.Height *= factor
}

rect := Rectangle{10, 5}
fmt.Println(rect.Area()) // 输出 50
rect.Scale(2)
fmt.Println(rect.Area()) // 输出 200
```
  1. 接收者类型（值接收者 vs. 指针接收者）：
    • 值接收者：方法操作的是接收者的一个副本。如果想修改接收者的原始值，值接收者是无效的。
    • 指针接收者：方法操作的是接收者的内存地址。可以通过指针修改接收者的原始值，也更适用于大型结构体，避免复制开销。

B. 接口（Interfaces）
接口定义了一组方法的集合。一个类型只要实现了接口中所有的方法，就称该类型实现了这个接口。
1. 定义接口：
go
type Geometry interface {
Area() float64
Perimeter() float64
}
2. 隐式实现：Go语言的接口实现是隐式的，不需要显式声明。
“`go
type Circle struct {
Radius float64
}

func (c Circle) Area() float64 {
    return math.Pi * c.Radius * c.Radius
}

func (c Circle) Perimeter() float64 {
    return 2 * math.Pi * c.Radius
}

// Circle 类型隐式实现了 Geometry 接口
func Measure(g Geometry) {
    fmt.Println(g)
    fmt.Println(g.Area())
    fmt.Println(g.Perimeter())
}

c := Circle{Radius: 10}
Measure(c)
```
  1. 空接口 (interface{})：可以持有任何类型的值。
    go
    var i interface{}
    i = 42
    fmt.Println(i)
    i = "hello"
    fmt.Println(i)
  2. 类型断言与类型开关：

    • 类型断言：用于从空接口中提取底层值。
      “`go
      var i interface{} = “hello”
      s := i.(string) // 断言i是string类型
      fmt.Println(s)

      s, ok := i.(string) // 安全断言，检查是否成功
      if ok {
      fmt.Println(s)
      }
      * **类型开关**：判断接口变量的动态类型。go
      func do(i interface{}) {
      switch v := i.(type) {
      case int:
      fmt.Printf(“这是一个整数 %d\n”, v)
      case string:
      fmt.Printf(“这是一个字符串 %s\n”, v)
      default:
      fmt.Printf(“未知类型 %T\n”, v)
      }
      }
      do(21)
      do(“world”)
      “`

VI. 并发（Goroutines 和 Channels）

Go语言的并发模型是其最强大的特性之一。

A. Goroutines
Goroutine是Go运行时管理的轻量级线程。它们比操作系统线程开销小得多。
1. go 关键字：在函数调用前加上 go 关键字即可启动一个Goroutine。
“`go
func say(s string) {
for i := 0; i < 3; i++ {
time.Sleep(100 * time.Millisecond)
fmt.Println(s)
}
}

func main() {
    go say("world") // 启动一个Goroutine
    say("hello")    // 在主Goroutine中执行
}
```
（注意：主Goroutine结束时，所有其他Goroutine也会终止。）

  1. sync.WaitGroup：用于等待一组Goroutine完成。
    “`go
    func worker(id int, wg *sync.WaitGroup) {
    defer wg.Done() // 在函数退出时调用wg.Done()
    fmt.Printf(“Worker %d starting\n”, id)
    time.Sleep(time.Second)
    fmt.Printf(“Worker %d done\n”, id)
    }

    func main() {
    var wg sync.WaitGroup
    for i := 1; i <= 5; i++ {
    wg.Add(1) // 增加WaitGroup计数器
    go worker(i, &wg)
    }
    wg.Wait() // 等待所有worker Goroutine完成
    fmt.Println(“All workers finished”)
    }
    “`

B. Channels
Channel是Goroutine之间进行通信的管道。
1. 创建Channel：
go
ch := make(chan int) // 创建一个无缓冲的int类型Channel
bufCh := make(chan string, 3) // 创建一个容量为3的缓冲string类型Channel
2. 发送和接收数据：
* 发送：ch <- value
* 接收：value := <-ch
“`go
func sum(s []int, c chan int) {
sum := 0
for _, v := range s {
sum += v
}
c <- sum // 将和发送到Channel
}

func main() {
    s := []int{7, 2, 8, -9, 4, 0}
    c := make(chan int)
    go sum(s[:len(s)/2], c)
    go sum(s[len(s)/2:], c)
    x, y := <-c, <-c // 从Channel接收数据
    fmt.Println(x, y, x+y) // 输出两个Goroutine计算的部分和，以及总和
}
```
  1. 缓冲Channel：
    go
    ch := make(chan int, 2)
    ch <- 1 // 放入元素1
    ch <- 2 // 放入元素2
    // ch <- 3 // 如果继续放会阻塞，直到有元素被取出
    fmt.Println(<-ch) // 取出元素1
    fmt.Println(<-ch) // 取出元素2

  2. select 语句：用于同时等待多个Channel操作。
    “`go
    func fibonacci(c, quit chan int) {
    x, y := 0, 1
    for {
    select {
    case c <- x: // 尝试向c发送x
    x, y = y, x+y
    case <-quit: // 尝试从quit接收
    fmt.Println(“quit”)
    return
    }
    }
    }

    func main() {
    c := make(chan int)
    quit := make(chan int)
    go func() {
    for i := 0; i < 10; i++ {
    fmt.Println(<-c)
    }
    quit <- 0 // 发送退出信号
    }()
    fibonacci(c, quit)
    }
    ``
    5. **关闭Channel和    range**：发送者可以通过close(ch)关闭Channel。接收者可以通过for range循环或v, ok := <-ch` 检查Channel是否关闭。

VII. 错误处理（Error Handling）

Go语言采用显式的错误处理机制，通过函数返回一个 error 类型的值。
1. 惯用的错误处理：
“`go
func divide(a, b float64) (float64, error) {
if b == 0 {
return 0, errors.New(“除数不能为0”) // 返回一个错误
}
return a / b, nil // 成功时返回结果和nil
}

func main() {
    result, err := divide(10, 2)
    if err != nil {
        fmt.Println("错误:", err)
    } else {
        fmt.Println("结果:", result)
    }

    result, err = divide(10, 0)
    if err != nil {
        fmt.Println("错误:", err) // 输出：错误: 除数不能为0
    }
}
```
  1. 创建错误：
    • errors.New("错误消息")：创建一个简单的错误。
    • fmt.Errorf("格式化错误: %w", err)：创建一个格式化的错误，并可以包装（wrap）底层错误。

  2. 自定义错误类型：
    “`go
    type MyError struct {
    Code int
    Msg string
    }

    func (e *MyError) Error() string {
    return fmt.Sprintf(“错误码: %d, 消息: %s”, e.Code, e.Msg)
    }

    func doSomething() error {
    return &MyError{Code: 500, Msg: “内部服务器错误”}
    }
    ``
    4. **    panic和recover**：
    *    panic：用于表示程序无法恢复的错误，会终止程序的正常执行。
    *    recover：用于从panic中恢复，只能在defer函数中使用。
    * **何时使用**：    panic和recover应谨慎使用，通常只用于发生不可预料的严重错误时。在大多数情况下，应使用error` 进行错误处理。

VIII. 文件I/O和基本网络

A. 读写文件 (os 包)
“`go
import (
“bufio”
“io/ioutil”
“os”
)

func main() {
// 写入文件
err := ioutil.WriteFile(“output.txt”, []byte(“Hello Go!”), 0644)
if err != nil {
panic(err)
}

// 读取文件
data, err := ioutil.ReadFile("output.txt")
if err != nil {
    panic(err)
}
fmt.Println(string(data))

// 按行读取
file, err := os.Open("output.txt")
if err != nil {
    panic(err)
}
defer file.Close() // 确保文件关闭

scanner := bufio.NewScanner(file)
for scanner.Scan() {
    fmt.Println(scanner.Text())
}

}
“`

B. 基本HTTP服务器 (net/http 包)
“`go
import (
“fmt”
“net/http”
)

func helloHandler(w http.ResponseWriter, r *http.Request) {
fmt.Fprintf(w, “Hello, world from Go!”)
}

func main() {
http.HandleFunc(“/”, helloHandler) // 注册路由
fmt.Println(“Server listening on :8080”)
http.ListenAndServe(“:8080”, nil) // 启动HTTP服务器
}
``
运行此程序后，访问http://localhost:8080` 即可看到 “Hello, world from Go!”。

IX. 测试（Testing）

Go语言内置了强大的测试工具。
1. 编写单元测试：
创建一个与源代码文件同目录的 _test.go 文件，例如 mymath_test.go：
“`go
// mymath_test.go
package mymath

import "testing"

func TestAdd(t *testing.T) {
    sum := Add(1, 2)
    expected := 3
    if sum != expected {
        t.Errorf("Add(1, 2) 期望 %d, 得到 %d", expected, sum)
    }
}
```
  1. 运行测试：
    在命令行中导航到包目录，运行 go test。
    您可以使用 go test -v 查看详细的测试输出。
  2. 表驱动测试（Table-driven Tests）：一种常见的Go测试模式，用于测试多个输入/输出对。

X. Go Modules（依赖管理）

Go Modules是Go官方的依赖管理系统。
1. 初始化模块：
在项目根目录运行 go mod init <module_path>。例如：go mod init github.com/yourusername/myproject。
这会创建一个 go.mod 文件。
2. 添加和更新依赖：
当您 import 一个新的第三方包并编译代码时，Go会自动下载并添加到 go.mod 文件中。您也可以手动运行：
* go get <package_path>：下载并添加到依赖。
* go mod tidy：清理不再使用的依赖，并添加缺少的依赖。
3. 构建和运行：
使用 go build 和 go run 命令时，Go会自动根据 go.mod 文件管理依赖。

XI. 后续学习 / 进阶主题

恭喜您完成了Go语言的入门学习！Go语言还有更多高级特性和应用领域值得探索：

  • 反射（Reflection）：在运行时检查类型信息和操作变量。
  • Context 包：用于在Goroutine之间传递请求范围的数据、截止日期和取消信号。
  • 泛型（Generics，Go 1.18+）：允许编写更通用、可重用的代码。
  • 构建命令行工具：使用 flag、cobra 等库。
  • Web开发框架：如 Gin、Echo、Beego 等。
  • 数据库操作：database/sql 包及其各种驱动。
  • 微服务架构：Go在构建微服务方面表现出色。

祝您在Go语言的学习旅程中一切顺利！

滚动至顶部