go语言学习笔记

发表于 | 分类于
字数统计: 18k

📋 知识地图

说明：✅ = 已有覆盖（可继续深化）　⬜ = 待扩充

一、Go 语言概述

  • ✅ Go 的设计哲学（简单、并发、高效编译）
  • ✅ 与 C / Java 的对比定位
  • ⬜ Go 版本演进与 Go Modules 的由来
  • ⬜ Go 适用领域（云原生 / CLI 工具 / 微服务 / DevOps）

二、开发环境

  • ⬜ Go 安装与环境变量（GOROOT / GOPATH / GOBIN）
  • ⬜ Go Modules 包管理（go mod init / tidy / vendor）
  • ⬜ 常用 IDE / 编辑器配置（VS Code + gopls）
  • ⬜ gofmt / goimports 代码格式化

三、程序结构与语法基础

  • ✅ Hello World 与包声明（package main）
  • ✅ 数据类型（bool / string / int 系列 / float / byte / rune）
  • ✅ 变量声明（var / 短声明 := / 批量声明）
  • ✅ 常量与 iota 枚举
  • ⬜ 零值（zero value）概念
  • ⬜ 类型转换（Go 无隐式转换）

四、容器与集合

  • ✅ 数组（固定长度）
  • ✅ 切片（slice）：make / append / copy / 切片截取
  • ✅ Map：声明 / 增删改查 / 遍历
  • ⬜ 切片底层原理（len vs cap / 扩容机制）
  • ⬜ range 遍历的各种用法
  • ⬜ 字符串与 rune 的关系（Unicode 处理）

五、流程控制

  • ✅ if / else if / else
  • ✅ switch（Go 特色的无条件 switch）
  • ✅ for 循环（Go 唯一循环语句）
  • ✅ break / continue / goto
  • ⬜ fallthrough 在 switch 中的使用
  • ⬜ defer 延迟执行（资源清理）

六、函数

  • ✅ 函数声明（func、参数、返回值）
  • ✅ 多返回值
  • ✅ 函数作为值（func 类型变量）
  • ⬜ 可变参数（…）
  • ⬜ 匿名函数与闭包
  • ⬜ defer 的执行顺序（LIFO 栈）
  • ⬜ panic / recover 异常处理机制

七、结构体与方法

  • ✅ 结构体定义与实例化
  • ✅ 方法与接收者（receiver）
  • ⬜ 值接收者 vs 指针接收者的选择
  • ⬜ 结构体嵌入（组合优于继承）
  • ⬩ 结构体标签（tags）与 JSON 序列化
  • ⬜ new vs make 的区别

八、接口（interface）—— Go 的核心抽象

  • ✅ 接口定义与实现（隐式实现）
  • ⬜ 空接口 interface{} 与 any（Go 1.18+）
  • ⬜ 类型断言（type assertion）
  • ⬜ 类型选择（type switch）
  • ⬜ 常用标准接口：Stringer / Reader / Writer / Error
  • ⬜ 接口组合

九、并发编程（Go 最大杀器）

  • ⬜ goroutine 概念与启动（go 关键字）
  • ⬜ channel（无缓冲 / 有缓冲 / 关闭 / 遍历）
  • ⬜ select 多路复用
  • ⬜ sync 包：WaitGroup / Mutex / RWMutex / Once
  • ⬜ 并发模式：生产者-消费者 / 扇出扇入 / Pipeline
  • ⬜ context 上下文（超时、取消、传值）
  • ⬜ 并发陷阱：数据竞态（race condition）、死锁
  • ⬜ go run -race 竞态检测

十、错误处理

  • ⬜ Go 的 error 接口设计哲学
  • ⬜ errors.New / fmt.Errorf
  • ⬜ 错误包装与解包（%w / errors.Unwrap）
  • ⬜ 自定义错误类型
  • ⬜ 错误处理最佳实践（不吞错误）

十一、包管理与工程结构

  • ⬜ Go Modules 深入（go.mod / go.sum / 版本锁定）
  • ⬜ 包导入规则（公开/私有：大小写首字母）
  • ⬜ 标准项目布局（cmd / internal / pkg / api）
  • ⬜ 依赖管理与版本升级

十二、标准库精选

  • ⬜ fmt：格式化 I/O
  • ⬜ net/http：HTTP 客户端与服务器
  • ⬜ encoding/json：JSON 序列化
  • ⬜ os / io / bufio：文件与 I/O 操作
  • ⬜ time：时间处理
  • ⬜ testing：单元测试与基准测试
  • ⬜ flag：CLI 参数解析

十三、测试

  • ⬜ 单元测试（TestXxx / t.Run / table-driven tests）
  • ⬜ 表格驱动测试模式
  • ⬜ 基准测试（BenchmarkXxx）
  • ⬜ TestMain 与测试初始化
  • ⬜ testify 第三方断言库

十四、实战项目参考

  • ⬜ 简易 HTTP REST API
  • ⬜ CLI 工具开发（cobra 框架）
  • ⬜ 数据库操作（database/sql + 驱动）

go语言基础知识

go语言基础知识

基础于c，具有部署简单、并发号、执行性能好的特点。与java相比，没有类和继承，相比java更加高效，相比c更加简单易编译。go对多核心优化好，可让程序员调用硬件更多性能。在很多语法现象上有从c语言简化，同时为了降低歧义和程序员语言风格对代码功能的影响，对代码书写方式和工程文件结构等做了规定。

hello world

1
2
3
4
5
6
7
package main    // 声明 main 包，main包是唯一的，是入口。
import (
    "fmt"       // 导入 fmt 包，打印字符串是需要用到
)
func main() {   // 声明 main 主函数，所以函数以func开头。func 函数名 (参数列表) (返回值列表)
    fmt.Println("Hello World!") // 打印 Hello World!
}

go语言以包为管理单位，每个go源文件需要声明其所属包，一目录下同级文件属于同一个包。

数据类型和变量生成

数据类型

  • bool 布尔
  • string 字符串
  • int、int8、int16、int32、int64 整型（分别8进制、16进制、32进制等）
  • uint、uint8、uint16、uint32、uint64、uintptr
  • byte // uint8 的别名
  • float32、float64 实型

变量赋值方式

var name type 变量声明方式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
var (  //批量变量
    a int =3 //不需要“；”
    b string
    c []float32
    d func() bool
    e struct {
        x int
    }
)

a,s:=1, "abc"//简化申明和赋值
c:=a+a
ptr := &v  //指针变量
var a,b *int  //指针变量
var q [3]int = [3]int{1, 2, 3}  //数组同时赋值

全局变量在主函数之外进行声明。

GO语言容器

数组遍历

1
2
3
4
5
6
7
var team [3]string
team[0] = "hammer"
team[1] = "soldier"
team[2] = "mum"
for k, v := range team {  //k如计数器，从0开始。v作为桥梁，获取数组team的值
    fmt.Println(k, v)
}

切片

1
2
3
4
5
fmt.Println(team[1:2])  //输出数组第二和第三个的内容。相当于生成切片。
b := make([]int, 2, 10)  //使用make函数，预分配10个内存空间，但使用2个元素

var a []int
a = append(a, 1, 2, 3)  // append追加多个元素, 手写解包方式。还有copy复制切片等

map概念（python中的字典）

map是一种特殊的数据结构，是由key（索引）和value（值）两个元素组合成的无序集合。map的容量是动态的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package main
import "fmt"
func main() {
    var mapLit map[string]int  //分别是map名、map结合值中的key的类型以及map的值的类型
    mapLit = map[string]int{"one": 1, "two": 2}
    mapCreated := make(map[string]int)
    mapCreated["key1"] = 4.5
    mapCreated["key2"] = 3.14159
    fmt.Printf("Map literal at \"one\" is: %d\n", mapLit["one"])
    fmt.Printf("Map created at \"key2\" is: %f\n", mapCreated["key2"])

}

scene := make(map[string]int)
scene["route"] = 66
scene["brazil"] = 4
scene["china"] = 960
delete(scene, "brazil")  //删除一组值
for k, v := range scene {  //遍历
    fmt.Println(k, v)
}

go语言程序结构

判断

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
if condition1 {
    // do something
} else if condition2 {
    // do something else
}else {
    // catch-all or default
}

var s = "hello"
switch {
case s == "hello":  //case 判断表达式
    fmt.Println("hello")
    fallthrough
case s != "world":
    fmt.Println("world")
}

循环

只支持for循环

1
2
3
4
5
6
7
8
sum := 0
for i := 0; i < 10; i++ {
    sum += i
}

for key, val := range coll {  //常用语遍历的循环模式，其中key作为递增。val是只读传递数值
    ...
}

break退出本次循环。 goto可以直接跳出多层循环到标签处。

1
2
3
4
goto breakHere

breakHere:
    fmt.Println("done")

函数

一般函数声明

1
2
3
4
5
6
7
func typedTwoValues() (int, int) {
    return 1, 2
}
func main() {
    a, b := typedTwoValues()
    fmt.Println(a, b)
}
1
2
3
4
5
6
7
8
9
10
11
12
package main
import (
    "fmt"
)
func fire() {
    fmt.Println("fire")
}
func main() {
    var f func()  //将func函数当做一种类型，定义一个f变量
    f = fire  //调用变量，相当于无传入的函数
    f()
}

结构体

go语言没有类的概念,结构体与c语言类似。（不过我感觉c和go的结构体和java的类挺相似，因为都可以属性继承等。）

1
2
3
4
5
6
7
type Point struct {  //结构体定义
    X int
    Y string
}

var p Point  //实例化
p.X = 10  //调用

接口概念

虽然go没有类和继承的概念，但其通过接口的概念实现面对对象的特性（一种抽象的存在）。

1
2
3
4
type writer interface{  //定义接口名，interface是定义接口关键词。接口类型由数个方法构成，默认在接口名后面加er以便于区分
    Write([]byte) error
    方法名（参数列表） 返回值
}
-------------本文结束感谢您的阅读-------------