🚀 Golang 基础学习笔记

📑 目录

1. 🗂️ Go 语言简介
2. ⚙️ 开发环境搭建
3. 📝 第一个 Go 程序
4. 📖 基本语法
5. 🔢 数据类型
6. 🔄 控制流程
7. ⚡ 函数
8. 📦 包和模块
9. 🏗️ 结构体和方法
10. 🔌 接口
11. 🔥 并发编程
12. ⚠️ 错误处理
13. 📚 常用标准库

1. 🗂️ Go 语言简介

1.1 什么是 Go

Go（又称 Golang）是 Google 开发的一种静态类型、编译型、并发式编程语言，于 2009 年正式发布。

1.2 Go 的特点

• 💨 简洁高效：语法简洁，学习曲线平缓
• ⚡ 高性能：编译成机器码，执行效率高
• 🔀 并发支持：原生支持 goroutine 和 channel
• 🧹 垃圾回收：自动内存管理
• 🌍 跨平台：支持多平台编译
• 🔒 静态类型：编译时类型检查，安全性高

1.3 Go 的应用场景

• 🖥️ 服务器端开发
• ☸️ 云原生/容器化应用（Docker、Kubernetes）
• 🌐 网络编程
• 🔗 分布式系统
• 💻 命令行工具
• 🏛️ 微服务架构

2. ⚙️ 开发环境搭建

2.1 安装 Go

🍎 macOS（使用 Homebrew）：

brew install go

🪟 Windows（使用 winget）：

winget install GoLang.Go

✅ 验证安装：

go version

2.2 IDE 推荐

• 📝 VS Code：安装 Go 扩展
• 💎 GoLand：JetBrains 出品，功能强大
• 📠 Vim/Neovim：安装 vim-go 插件

2.3 GOPATH 与 Go Modules

从 Go 1.11 开始，推荐使用 Go Modules 管理依赖：

# 初始化模块go mod init module_name# 下载依赖go mod tidy

3. 📝 第一个 Go 程序

3.1 Hello World

创建文件 main.go：

package mainimport"fmt"funcmain() {    fmt.Println("Hello, World!")}

3.2 运行程序

# 编译并运行go run main.go# 编译为可执行文件go build main.go./main

4. 📖 基本语法

4.1 变量声明

// 方法一：声明并初始化var name string = "Alice"// 方法二：类型推断var age = 25// 方法三：短变量声明（函数内）city := "Beijing"// 声明多个变量var (    firstName string = "John"    lastName  string = "Doe")

4.2 常量

const PI = 3.14159const (    StatusOK    = 200    StatusNotFound = 404)

4.3 注释

// 单行注释/* 多行 注释*/

5. 🔢 数据类型

5.1 基础类型

// 布尔类型var isActive bool = true// 整数var a int = 10// 有符号整数var b int8 = 127// 8位有符号整数var c int16 = 32767// 16位有符号整数var d int32 = 2147483647var e int64 = 9223372036854775807// 无符号整数var f uint = 10var g uint8 = 255var h uint16 = 65535var i uint32 = 4294967295var j uint64 = 18446744073709551615// 浮点数var k float32 = 3.14var l float64 = 3.141592653589793// 复数var m complex64 = complex(1, 2)var n complex128 = complex(1, 2)// 字节和字符var o byte = 'A'var p rune = '中'// 字符串var q string = "Hello, Go!"

5.2 派生类型

// 数组var arr [5]int = [5]int{1, 2, 3, 4, 5}// 切片（动态数组）slice := []int{1, 2, 3, 4, 5}// 映射（字典）m := map[string]int{"apple":  5,"banana": 3,}// 指针ptr := &arr[0]// 结构体type Person struct {    Name string    Age  int}

5.3 类型转换

var i int = 42var f float64 = float64(i)var u uint = uint(i)

6. 🔄 控制流程

6.1 if 条件语句

score := 85if score >= 90 {    fmt.Println("优秀")} elseif score >= 60 {    fmt.Println("及格")} else {    fmt.Println("不及格")}// 条件判断前可以赋值if age := 20; age >= 18 {    fmt.Println("成年")}

6.2 for 循环

// 基本形式for i := 0; i < 10; i++ {    fmt.Println(i)}// 省略初始值和递增i := 0for i < 10 {    i++}// 无限循环for {// ...if condition {break    }}// range 遍历nums := []int{1, 2, 3, 4, 5}for index, value := range nums {    fmt.Printf("Index: %d, Value: %d\n", index, value)}

6.3 switch 语句

day := "Monday"switch day {case"Monday", "Tuesday", "Wednesday", "Thursday", "Friday":    fmt.Println("工作日")case"Saturday", "Sunday":    fmt.Println("周末")default:    fmt.Println("无效的日期")}// switch 后不跟表达式，行为类似 if-elsescore := 85switch {case score >= 90:    fmt.Println("A")case score >= 80:    fmt.Println("B")case score >= 60:    fmt.Println("C")default:    fmt.Println("D")}

6.4 跳转语句

// break：跳出循环for i := 0; i < 10; i++ {if i == 5 {break    }    fmt.Println(i)}// continue：跳过本次迭代for i := 0; i < 5; i++ {if i == 2 {continue    }    fmt.Println(i)}// goto：跳转到标签（慎用）goto Label// ...Label:fmt.Println("jump here")

7. ⚡ 函数

7.1 基本函数

// 无返回值funcgreet(name string) {    fmt.Printf("Hello, %s!\n", name)}// 单返回值funcadd(a, b int)int {return a + b}// 多返回值funcdivide(a, b int)(int, error) {if b == 0 {return0, errors.New("除数不能为零")    }return a / b, nil}// 命名返回值funcswap(a, b int)(x int, y int) {    x = b    y = areturn// 裸返回}

7.2 可变参数

funcsum(nums ...int)int {    total := 0for _, n := range nums {        total += n    }return total}funcmain() {    fmt.Println(sum(1, 2, 3, 4, 5)) // 输出: 15}

7.3 匿名函数与闭包

// 匿名函数add := func(a, b int)int {return a + b}fmt.Println(add(1, 2))// 闭包funccounter()func()int {    count := 0returnfunc()int {        count++return count    }}funcmain() {    next := counter()    fmt.Println(next()) // 1    fmt.Println(next()) // 2    fmt.Println(next()) // 3}

7.4 函数作为参数和返回值

funcapply(op func(int, int)int, a, bint) int {return op(a, b)}funcmultiply(a, b int)int {return a * b}funcmain() {    result := apply(multiply, 3, 4)    fmt.Println(result) // 12}

8. 📦 包和模块

8.1 包的概念

Go 程序由包组成，每个文件开头声明包名：

package main  // 主包package utils  // 自定义包

8.2 导入包

import ("fmt"// 标准库"math"// 标准库"github.com/package"// 第三方包    mypackage " ./mypackage"// 本地包（使用别名）)

8.3 init 函数

每个包可以有一个 init() 函数，在包被导入时自动执行：

package utilsimport"fmt"funcinit() {    fmt.Println("utils package initialized")}

8.4 Go Modules

# 初始化模块go mod init github.com/username/project# 添加依赖go get github.com/pkg/errors# 更新依赖go get -u all# 整理依赖go mod tidy# 下载依赖到本地go mod download# 查看依赖go list -m allgo mod graph

9. 🏗️ 结构体和方法

9.1 定义结构体

type Person struct {    Name    string    Age     int    Email   string    Address string}

9.2 创建和初始化结构体

// 方式一：按字段名p1 := Person{    Name:  "Alice",    Age:   30,    Email: "alice@example.com",}// 方式二：按字段顺序p2 := Person{"Bob", 25, "bob@example.com", ""}// 方式三：使用 newp3 := new(Person)p3.Name = "Charlie"

9.3 方法

type Rectangle struct {    Width  float64    Height float64}// 值接收者方法func(r Rectangle)Area()float64 {return r.Width * r.Height}// 指针接收者方法func(r *Rectangle)Scale(factor float64) {    r.Width *= factor    r.Height *= factor}// 链式调用示例func(r Rectangle)SetWidth(width float64)Rectangle {    r.Width = widthreturn r}

9.4 结构体嵌套和继承

type Address struct {    City    string    Country string}type Employee struct {    Name    string    Salary  float64    Address        // 匿名嵌套（组合）}funcmain() {    emp := Employee{        Name:   "Alice",        Salary: 5000,        Address: Address{            City:    "Beijing",            Country: "China",        },    }    fmt.Println(emp.City) // 直接访问嵌套字段}

10. 🔌 接口

10.1 定义接口

type Writer interface {    Write([]byte) (int, error)}type Reader interface {    Read([]byte) (int, error)}// 多个方法的接口type ReadWriter interface {    Reader    Writer}

10.2 实现接口

在 Go 中，只要类型实现了接口的所有方法，就隐式实现了该接口：

type Integer intfunc(i Integer)String()string {return strconv.Itoa(int(i))}type Stringer interface {    String() string}funcprintString(s Stringer) {    fmt.Println(s.String())}funcmain() {var i Integer = 42    printString(i)}

10.3 空接口

// 空接口可以存储任何值var any interface{} = "hello"any = 42any = []int{1, 2, 3}// 类型断言str, ok := any.(string)if ok {    fmt.Println(str)}// switch 类型判断switch v := any.(type) {casestring:    fmt.Println("string:", v)caseint:    fmt.Println("int:", v)default:    fmt.Println("unknown type")}

10.4 常用内置接口

// Stringer 接口type Stringer interface {    String() string}// Error 接口type error interface {    Error() string}// Go 中的接口（隐式实现）// sort.Interface 需要实现 Len(), Less(), Swap()

11. 🔥 并发编程

11.1 Goroutine

goroutine 是 Go 轻量级的线程，由 Go 运行时管理：

funcsay(s string) {for i := 0; i < 5; i++ {        fmt.Println(s)    }}funcmain() {// 并发执行go say("world")    say("hello")}

11.2 Channel

channel 用于 goroutine 之间的通信：

// 创建 channelch := make(chanint)// 发送数据gofunc() {    ch <- 42}()// 接收数据value := <-chfmt.Println(value)// 关闭 channelclose(ch)// 带缓冲的 channelbuffered := make(chanint, 10)// 单向 channelsendOnly := make(chan<- int)recvOnly := make(<-chanint)

11.3 Select

select 用于监听多个 channel 的 IO 操作：

funcmain() {    ch1 := make(chanint)    ch2 := make(chanint)gofunc() {        time.Sleep(1 * time.Second)        ch1 <- 1    }()gofunc() {        time.Sleep(2 * time.Second)        ch2 <- 2    }()for i := 0; i < 2; i++ {select {case msg1 := <-ch1:            fmt.Println("Received from ch1:", msg1)case msg2 := <-ch2:            fmt.Println("Received from ch2:", msg2)case <-time.After(3 * time.Second):            fmt.Println("Timeout")        }    }}

11.4 并发安全

// 使用 sync.Mutexvar mu sync.Mutexvar counter intfuncincrement() {    mu.Lock()    counter++    mu.Unlock()}// 使用 sync.WaitGroupvar wg sync.WaitGroupfuncworker(id int) {defer wg.Done()    fmt.Printf("Worker %d starting\n", id)    time.Sleep(time.Second)    fmt.Printf("Worker %d done\n", id)}funcmain() {for i := 1; i <= 5; i++ {        wg.Add(1)go worker(i)    }    wg.Wait()}// 使用 sync.Map（并发安全的 map）var safeMap sync.MapsafeMap.Store("key", "value")value, ok := safeMap.Load("key")

11.5 Context

import"context"funcworkerWithContext(ctx context.Context) {for {select {case <-ctx.Done():            fmt.Println("Worker stopped:", ctx.Err())returndefault:            fmt.Println("Working...")            time.Sleep(500 * time.Millisecond)        }    }}funcmain() {    ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)defer cancel()    workerWithContext(ctx)}

12. ⚠️ 错误处理

12.1 Go 的错误处理哲学

Go 使用返回错误值的方式处理错误，而不是异常机制：

// 错误接口type error interface {    Error() string}// 标准库 errorsimport"errors"funcdivide(a, b float64)(float64, error) {if b == 0 {return0, errors.New("division by zero")    }return a / b, nil}funcmain() {    result, err := divide(10, 0)if err != nil {        fmt.Println("Error:", err)return    }    fmt.Println("Result:", result)}

12.2 自定义错误

type MyError struct {    Code    int    Message string}func(e *MyError)Error()string {return fmt.Sprintf("Error %d: %s", e.Code, e.Message)}funcdivide(a, b float64)(float64, error) {if b == 0 {return0, &MyError{Code: 1001, Message: "division by zero"}    }return a / b, nil}

12.3 错误链

import"fmt"funcreadFile(filename string)error {return fmt.Errorf("failed to read file: %w", os.ErrNotExist)}funcprocessData(filename string)error {    err := readFile(filename)if err != nil {return fmt.Errorf("process failed: %w", err)    }returnnil}funcmain() {    err := processData("nonexistent.txt")if err != nil {        fmt.Printf("Error: %v\n", err)// 使用 errors.Is 检查错误链if errors.Is(err, os.ErrNotExist) {            fmt.Println("File does not exist")        }    }}

12.4 panic 和 recover

funcsafeCall() {deferfunc() {if r := recover(); r != nil {            fmt.Println("Recovered from panic:", r)        }    }()panic("something went wrong")}funcmain() {    safeCall()    fmt.Println("Program continues...")}

13. 📚 常用标准库

13.1 fmt - 格式化 I/O