基础部分 on 编程那些事儿

第1章词法元素

Fri, 20 Mar 2026 08:39:00 +0800

第1章词法元素

你好啊！欢迎来到 Go 语言的第一章！这一章我们要聊的是 Go 代码的"基因"——词法元素。想象一下，如果把一门编程语言比作一个活生生的人，那词法元素就是这个人身上的细胞、器官和 DNA 序列。别担心，我会让这段旅程变得有趣而不是催眠。准备好了吗？Let’s Go！（看，我已经在用双关语了，这就是 Go 语言的魅力！）

第2章特殊指令与构建约束

Fri, 20 Mar 2026 08:39:00 +0800

第2章特殊指令与构建约束

欢迎来到第二章！这一章我们要聊的是 Go 语言的"隐身术"——特殊指令和构建约束。你知道吗？Go 的代码可以在不同平台上有不同的表现，就像变色龙一样，可以根据环境改变颜色。构建约束就是 Go 语言的"变色"机制，而特殊指令则是一些"魔法咒语"，可以改变编译器的行为。准备好了吗？让我们开始这段"魔法"之旅！

第3章类型系统

Fri, 20 Mar 2026 08:39:00 +0800

第3章类型系统

欢迎来到第三章！这一章我们要聊的是 Go 语言的"基因改造"——类型系统。如果说 Go 语言是一个人，那类型系统就是这个人的"血统认证"。Go 是一种静态类型语言，这意味着每个变量都有一个类型，而且这个类型在编译时就确定了。但 Go 的类型系统又比 C++/Java 简洁得多，它没有类、没有继承、没有泛型（呃，Go 1.18 有了）——但这些都不影响它成为一个强大的类型系统。准备好了吗？让我们开始！

第4章常量

Fri, 20 Mar 2026 08:39:00 +0800

第4章常量

欢迎来到第四章！这一章我们要聊的是 Go 语言的"不变"哲学——常量。常量就像是编程世界里的"刻在石头上"，一旦定义就不能改变。常量在 Go 中有很多独特的特性，比如可以在编译时计算确定的值，还有那个神秘的 iota 枚举器。准备好了吗？让我们开始！

第5章变量

Fri, 20 Mar 2026 08:39:00 +0800

第5章变量

欢迎来到第五章！这一章我们要聊的是 Go 语言的"变量"。变量是什么？变量就是一个有名字的盒子，你可以在里面放东西（值），也可以把东西拿出来用。想象一下你家的冰箱——冰箱就是一个变量，你可以往里面放牛奶（赋值），也可以拿出来喝（读取）。不同的是，Go 的冰箱永远不会被塞满，因为变量可以存储任意大小的数据……好吧，这个比喻好像不太对。总之，让我们开始探索变量的奥秘吧！

第6章语句概述

Fri, 20 Mar 2026 08:39:00 +0800

第6章语句概述

欢迎来到第六章！这一章我们要聊的是 Go 语言的"语句"。语句是什么？语句就是告诉计算机"做什么"的动作指令。如果说变量是名词，那语句就是动词——变量是名词的话，语句就是告诉计算机要做什么。顺序执行、条件判断、循环往复……这些都是语句的功能。准备好了吗？让我们开始吧！

第7章简单语句

Fri, 20 Mar 2026 08:39:00 +0800

第7章简单语句

欢迎来到第七章！这一章我们要聊的是 Go 语言的"简单语句"。简单语句是那些不需要大括号包围的独立语句，它们是 Go 代码的"基本粒子"。虽然叫"简单"，但功能可不简单哦！

第8章条件语句

Fri, 20 Mar 2026 08:39:00 +0800

第8章条件语句

欢迎来到第八章！这一章我们要聊的是 Go 语言的"条件语句"。条件语句是什么？条件语句就是让程序做决定的语句——“如果今天下雨，我就带伞；否则，我就去跑步。“这就是一个典型的条件语句。程序有了条件语句，就像人有了判断力，不再是"一根筋"地执行到底了。

第9章循环语句

Fri, 20 Mar 2026 08:39:00 +0800

第9章循环语句

欢迎来到第九章！这一章我们要聊的是 Go 语言的"循环语句"。循环是什么？循环就是让程序"重复做一件事"的结构。想象一下，你每天早上起床、刷牙，洗脸、上班……这就是一个循环。程序中的循环也是如此——让计算机反复执行一段代码，直到满足某个条件才停下来。Go 语言只有一种循环关键字：for，但它的用法可以变化出花来！

第10章选择语句

Fri, 20 Mar 2026 08:39:00 +0800

第10章选择语句

10.1 select 语句

10.1.1 select 语法

想象这样一个场景：你是一个婚礼司仪，面前站着三个伴郎，每个伴郎手里都攥着给新娘的表白信。但新娘只有一个，而且她有"选择困难症晚期"——她不想一个个问"你有什么要说的吗"，她只想知道：“谁先开口，我就嫁给谁。”

第11章跳转语句

Fri, 20 Mar 2026 08:39:00 +0800

第11章跳转语句

11.1 goto 语句

11.1.1 语法规则

goto 是什么？

goto 是编程语言中最古老、最简单、同时也是最"人人喊打"的一个跳转语句。它的原理粗暴得像个野蛮人——直接告诉电脑：“别废话，跳到那个标签那里去执行！”

第12章数组

Fri, 20 Mar 2026 08:39:00 +0800

第12章数组

12.1 数组类型

12.1.1 数组定义

数组是什么？

数组是 Go 语言中最基础的数据结构——它是一组相同类型的元素，按顺序排列，放在一个"连续的内存空间"里。

第13章切片

Fri, 20 Mar 2026 08:39:00 +0800

第13章切片

“数组是那块 immutable 的金漆招牌，切片才是 Go 程序员真正的日常。” —— 没有人说过这句话，但它是真的。

如果说数组是 Go 语言世界里的"固定座位"，那切片就是那个可以随时招呼朋友来坐、椅子不够就再搬一把的动态卡座。你可能在其他语言里见过"动态数组"、“列表”、“ArrayList"之类的概念——在 Go 里，这些统统叫切片（Slice）。

第14章 map

Fri, 20 Mar 2026 08:39:00 +0800

第14章 map

“切片是数组的窗户，map 就是哈希表的大脑。” —— 仍然是没有人说过的话，但很准确。

如果说切片是 Go 里的"动态数组"，那 map 就是 Go 里的哈希表（Hash Table）实现。切片用整数下标找元素，map 用键（key）找值（value）——键值对儿。你在其他语言里见过的 HashMap、Dictionary、Object（JS）、HashTable，都跟 Go 里的 map 是同一类东西。

第15章结构体

Fri, 20 Mar 2026 08:39:00 +0800

第15章结构体

“数组是把同类东西装进一个盒子，结构体是把不同类东西装进一个盒子。” —— 这是结构体存在的意义。

如果说数组是把同一种类型的数据打包成一组，那结构体就是把不同类型的数据打包成一个整体。你可以把结构体想象成一张表格：每一行是一个字段（field），每行有自己的名字和类型。比如一张学生信息表，有姓名（字符串）、年龄（整数）、身高（浮点数）——这些字段类型各不相同，只有结构体能装下它们。

第16章函数类型

Fri, 20 Mar 2026 08:39:00 +0800

第16章函数类型

“函数是 Go 的一等公民（first-class citizen）。” —— 这是 Go 语言的设计哲学之一。

在 Go 里，函数不只是用来调用的代码块——函数本身也是一种类型，可以像变量一样赋值、传递、作为参数、作为返回值。听起来有点抽象，但它带来的编程范式革命是巨大的：你可以在 Go 里写高阶函数、装饰器、回调、策略模式——这些在其他语言里需要特殊语法才能做到的事情，在 Go 里只是普通代码。

第17章函数

Fri, 20 Mar 2026 08:39:00 +0800

第17章函数

“函数是 Go 世界的公民，不是二等居民。” —— Rob Pike（Go 语言创始人之一）

函数是 Go 程序的基本构建单元。Go 的函数比其他语言的函数更强大、更灵活——它支持多返回值、命名返回值、闭包、变长参数、延迟执行（defer），还可以作为值传递。这些特性让 Go 在保持简洁的同时拥有了函数式编程的能力。

第18章方法

Fri, 20 Mar 2026 08:39:00 +0800

第18章方法

“对象和方法，是Go语言给你的超能力，让你像超级英雄一样给类型赋予超能力！”

想象一下，如果你是一个"人"类型，你现在可以给"人"类型安装一个"吃饭"的方法，从此每个"人"实例都会"吃饭"了——这就是Go语言的魔力所在！不像某些语言，非要把函数和类型强行塞进一个类里，Go语言告诉你：类型和函数可以是好朋友，方法只是函数的另一面！

第19章接口类型

Fri, 20 Mar 2026 08:39:00 +0800

第19章接口类型

接口（Interface），Go语言的"魔法契约"！如果说类型是"房产证"，那接口就是"职业资格证"——你不需要关心这个人姓甚名谁，只需要知道他能做什么。

第20章接口实现

Fri, 20 Mar 2026 08:39:00 +0800

第20章接口实现

Go语言的接口实现机制是"隐式的"，不需要implements关键字。只要方法签名对上了，编译器就会认可你"实现了"那个接口。这种设计叫做鸭子类型（Duck Typing）——“如果它走起来像鸭子，叫起来像鸭子，那它就是鸭子。”

第21章接口值

Fri, 20 Mar 2026 08:39:00 +0800

第21章接口值

接口值是Go语言中最有趣的数据结构之一。把它想象成一个"万能遥控器"——可以指向不同品牌的电视（具体类型），但遥控器本身的操作方式是固定的。

第22章类型断言

Fri, 20 Mar 2026 08:39:00 +0800

第22章类型断言

类型断言是Go语言处理接口值的"透视镜"。它允许你"窥视"接口内部，提取出具体的类型和值。

22.1 断言语法

22.1.1 直接断言

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32


package main

import "fmt"

type Writer interface {
 Write(p []byte) (n int, err error)
}

type File struct {
 name string
}

func (f *File) Write(p []byte) (n int, err error) {
 fmt.Printf("[File] 写入文件 %s: %s\n", f.name, string(p)) // [File] 写入文件 test.txt: Hello
 return len(p), nil
}

type StringWriter struct{}

func (s *StringWriter) Write(p []byte) (n int, err error) {
 fmt.Printf("[StringWriter] 写入: %s\n", string(p)) // [StringWriter] 写入: Another message
 return len(p), nil
}

func main() {
 var w Writer = &File{name: "test.txt"}
 f := w.(*File)
 fmt.Printf("断言成功，文件名: %s\n", f.name) // 断言成功，文件名: test.txt

 var w2 Writer = &StringWriter{}
 fmt.Printf("w2的类型: %T\n", w2) // w2的类型: *main.StringWriter
}

22.1.2 comma-ok 断言

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


package main

import "fmt"

func main() {
 var i interface{} = "hello world"

 if str, ok := i.(string); ok {
 fmt.Printf("断言成功: %q\n", str) // 断言成功: "hello world"
 }

 var i2 interface{} = 42
 if str, ok := i2.(string); ok {
 fmt.Printf("这行不会打印: %q\n", str)
 } else {
 fmt.Println("断言失败，i2不是string类型，是int") // 断言失败，i2不是string类型，是int
 }
}

22.1.3 多个类型尝试

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31


package main

import "fmt"

type Any interface{}

func inspect(i Any) {
 if v, ok := i.(string); ok {
 fmt.Printf("字符串类型: %q\n", v) // 字符串类型: "hello"
 return
 }

 if v, ok := i.(int); ok {
 fmt.Printf("整数类型: %d\n", v) // 整数类型: 42
 return
 }

 if v, ok := i.(float64); ok {
 fmt.Printf("浮点数类型: %f\n", v) // 浮点数类型: 3.140000
 return
 }

 fmt.Printf("未知类型: %T\n", i)
}

func main() {
 inspect("hello")
 inspect(42)
 inspect(3.14)
 inspect([]int{1, 2, 3})
}

22.2 断言成功的情况

22.2.1 断言为具体类型

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39


package main

import "fmt"

type Shape interface {
 Area() float64
}

type Circle struct {
 Radius float64
}

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

type Rectangle struct {
 Width, Height float64
}

func (r Rectangle) Area() float64 {
 return r.Width * r.Height
}

func main() {
 var s Shape = Circle{Radius: 5}

 fmt.Printf("接口动态类型: %T\n", s) // 接口动态类型: main.Circle

 if c, ok := s.(Circle); ok {
 fmt.Printf("成功断言为Circle，半径=%.2f，面积=%.2f\n", c.Radius, c.Area()) // 成功断言为Circle，半径=5.00，面积=78.54
 }

 if r, ok := s.(Rectangle); ok {
 fmt.Printf("Rectangle: %v\n", r)
 } else {
 fmt.Println("s不是Rectangle类型，它是Circle") // s不是Rectangle类型，它是Circle
 }
}

22.2.2 断言为接口类型

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42


package main

import "fmt"

type Reader interface {
 Read(p []byte) (n int, err error)
}

type Writer interface {
 Write(p []byte) (n int, err error)
}

type ReadWriter interface {
 Reader
 Writer
}

type File struct{}

func (f *File) Read(p []byte) (n int, err error) {
 fmt.Println("[File.Read] 读取") // [File.Read] 读取
 return len(p), nil
}

func (f *File) Write(p []byte) (n int, err error) {
 fmt.Println("[File.Write] 写入") // [File.Write] 写入
 return len(p), nil
}

func main() {
 var rw ReadWriter = &File{}

 if r, ok := rw.(Reader); ok {
 fmt.Printf("成功断言为Reader: %T\n", r) // 成功断言为Reader: *main.File
 r.Read(make([]byte, 10))
 }

 if w, ok := rw.(Writer); ok {
 fmt.Printf("成功断言为Writer: %T\n", w) // 成功断言为Writer: *main.File
 w.Write(make([]byte, 10))
 }
}

22.3 断言失败的情况

22.3.1 comma-ok断言安全处理

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29


package main

import "fmt"

type Any interface{}

func safeAssert(i Any) {
 fmt.Printf("尝试断言 %T: ", i)

 if s, ok := i.(string); ok {
 fmt.Printf("是字符串 %q\n", s)
 return
 }

 if n, ok := i.(int); ok {
 fmt.Printf("是整数 %d\n", n)
 return
 }

 fmt.Printf("不是字符串也不是整数\n")
}

func main() {
 fmt.Println("=== comma-ok断言安全处理 ===")

 safeAssert("hello") // 尝试断言 string: 是字符串 "hello"
 safeAssert(42) // 尝试断言 int: 是整数 42
 safeAssert(3.14) // 尝试断言 float64: 不是字符串也不是整数
}

22.3.2 类型选择处理

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41


package main

import "fmt"

type Any interface{}

func inspectType(i Any) {
 fmt.Printf("%v (类型: %T) -> ", i, i)

 switch v := i.(type) {
 case nil:
 fmt.Println("nil值")
 case int:
 fmt.Printf("整数: %d (两倍=%d)\n", v, v*2)
 case string:
 fmt.Printf("字符串: %q (长度=%d)\n", v, len(v))
 case float64:
 fmt.Printf("浮点数: %.2f\n", v)
 case bool:
 fmt.Printf("布尔值: %t\n", v)
 default:
 fmt.Printf("其他类型: %T\n", v)
 }
}

func main() {
 values := []Any{nil, 42, 7, "hi", true, 3.14}

 fmt.Println("=== type switch ===\n")

 for _, v := range values {
 inspectType(v)
 }

 // <nil> (类型: <nil>) -> nil值
 // 42 (类型: int) -> 整数: 42 (两倍=84)
 // 7 (类型: int) -> 整数: 7 (两倍=14)
 // hi (类型: string) -> 字符串: "hi" (长度=2)
 // true (类型: bool) -> 布尔值: true
 // 3.14 (类型: float64) -> 浮点数: 3.14
}

22.4 断言与接口类型转换

22.4.1 接口转具体类型

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39


package main

import "fmt"

type Writer interface {
 Write(p []byte) (n int, err error)
}

type File struct {
 name string
}

func (f *File) Write(p []byte) (n int, err error) {
 fmt.Printf("[File.Write] %s: %s\n", f.name, string(p)) // [File.Write] data.txt: test
 return len(p), nil
}

type StringWriter struct{}

func (s *StringWriter) Write(p []byte) (n int, err error) {
 fmt.Printf("[StringWriter.Write] %s\n", string(p)) // [StringWriter.Write] test
 return len(p), nil
}

func main() {
 var w Writer = &File{name: "data.txt"}

 if f, ok := w.(*File); ok {
 fmt.Printf("断言为*File成功: %s\n", f.name) // 断言为*File成功: data.txt
 f.Write([]byte("test"))
 }

 var w2 Writer = &StringWriter{}
 if f, ok := w2.(*File); ok {
 fmt.Println("这行不会打印")
 } else {
 fmt.Println("w2不是*File类型，无法断言") // w2不是*File类型，无法断言
 }
}

本章小结

本章我们学习了Go的类型断言：

第23章类型选择

Fri, 20 Mar 2026 08:39:00 +0800

第23章类型选择

类型选择（type switch）是Go语言处理多种接口类型的"超级开关"。如果说普通switch是根据值来选择分支，那type switch就是根据类型来选择分支。

第24章指针

Fri, 20 Mar 2026 08:39:00 +0800

第24章指针

指针是Go语言的"遥控器"。它不直接持有数据，而是指向数据的"地址"。想象你有一把钥匙（指针），可以打开任意一扇门（内存地址），看到里面的东西（值）。

第25章内存管理

Fri, 20 Mar 2026 08:39:00 +0800

第25章内存管理

Go语言以自动内存管理著称——你只管申请内存，不用操心释放，垃圾回收器（GC）会帮你搞定一切。就像有个贴心的管家，你吃完饭不用洗碗，管家会帮你处理。

第26章协程 Goroutine

Fri, 20 Mar 2026 08:39:00 +0800

第26章协程 Goroutine

如果说线程是"单线程社恐"，一次只能专心做一件事；那Goroutine就是"社交达人"，可以同时和很多人聊天！

第27章通道 Channel

Fri, 20 Mar 2026 08:39:00 +0800

第27章通道 Channel

通道是Go语言最有特色的发明！如果把Goroutine比作"分身术"，那Channel就是"电话线"——让分身之间可以互相通信、数据共享。

第28章同步原语

Fri, 20 Mar 2026 08:39:00 +0800

第28章同步原语

Go的sync包提供了各种同步原语，就像并发编程的"工具箱"。有了这些工具，多个协程才能安全地协作。

28.1 互斥锁 Mutex

28.1.1 为什么需要互斥锁

当多个协程同时访问共享变量时，会发生"数据竞争"：

第29章错误机制

Fri, 20 Mar 2026 08:39:00 +0800

第29章错误机制

Go的错误处理独树一帜！错误就是普通的返回值，没有异常机制。这不是缺陷，而是Go的设计哲学——错误是值，应该被显式处理。

想象你点外卖：

第30章异常机制

Fri, 20 Mar 2026 08:39:00 +0800

第30章异常机制

panic和recover是Go的"核武器"——不是用来处理普通错误的。它们是最后的手段，用于真正不可恢复的情况。

第31章包 Package

Fri, 20 Mar 2026 08:39:00 +0800

第31章包 Package

包（Package），Go语言代码的"集装箱"。它把相关的代码组织在一起，方便复用和管理。

31.1 包的基本概念

31.1.1 为什么需要包

想象一个大型项目：

第32章模块 Module

Fri, 20 Mar 2026 08:39:00 +0800

第32章：模块 Module

“如果把Go语言的世界比作一个大型购物中心，那么模块（Module）就是每个店铺的营业执照。没有它，你的代码就像是无证经营的小摊贩，随时可能被城管（编译器）没收。”

第33章泛型 Generics

Fri, 20 Mar 2026 08:39:00 +0800

第33章：泛型 Generics

“泛型，这个名字听起来像是某种神秘的力量，但实际上它是Go语言在1.18版本引入的最重要的特性。有了泛型，你终于可以写一份代码，服务于多种数据类型——就像一个万能厨师，用同一套厨艺做出各种口味的菜！”

第34章反射 Reflect

Fri, 20 Mar 2026 08:39:00 +0800

第34章：反射 Reflect

“反射（Reflection）是编程语言的’透视眼’，让你在运行时能够窥探和操作变量的类型信息。就像是去医院做X光检查，你能看见平时看不见的内部结构！”

第35章不安全编程 Unsafe

Fri, 20 Mar 2026 08:39:00 +0800

第35章不安全编程 Unsafe

35.1 unsafe 包

🧪 unsafe，翻译成中文就是"不安全"。在 Go 语言这个充满安全检查的温柔乡里，unsafe 包就像是一个调皮的孩子，专门干一些"越界"的事情。但别误会，它可不是真的让你去搞破坏——它更像是给了你一把钥匙，让你能够打开那些被 Go 编译器小心翼翼藏起来的底层秘密。

第36章文档

Mon, 23 Mar 2026 08:39:00 +0800

第36章文档

36.1 文档注释

📝 文档，听起来是个无聊透顶的话题对吧？写文档被认为是"程序员最讨厌的事情之一"，和"命名"并列第一。但是！你知道吗，优秀的文档可以让一个项目从"无人问津"变成"人手一份"；而糟糕的文档则可以让一个优秀的项目变成"无人能懂"的孤岛。这一章，我们就来聊聊 Go 语言的文档之道。

第37章 CGO

Mon, 23 Mar 2026 08:39:00 +0800

第37章 CGO

37.1 CGO 基础

🔗 CGO 是 Go 语言调用 C 代码的桥梁。如果说 Go 是一门现代化的、安全的、并发友好的编程语言，那么 C 就是那个"老前辈"——几十年的积累，无数的经典库，遍布全球的代码遗产。CGO 让你能够直接调用这些 C 代码，把 Go 的安全性和 C 的灵活性结合起来。

第38章创建型模式

Mon, 23 Mar 2026 08:39:00 +0800

第38章创建型模式

38.1 单例模式

👑 单例模式大概是所有设计模式中最"简单粗暴"的一个——一个类只能有一个实例，并且要提供一个全局访问点。这听起来很简单，但实现一个线程安全、延迟加载、高性能的单例，可没那么容易！

第39章结构型模式

Mon, 23 Mar 2026 08:39:00 +0800

第39章结构型模式

本章我们会看到代码世界里的"万能转换头"——适配器模式。就像你出国旅行时那个神奇的转换插头，不管你带的是什么电器，不管插座是什么形状，插上去都能用。这就是适配器的魅力：让本不兼容的接口，突然之间就能愉快地一起工作了。

第40章行为型模式

Mon, 23 Mar 2026 08:39:00 +0800

第40章行为型模式

如果说结构型模式是关于"对象的长相"，那么行为型模式就是关于"对象的举止"——它关注的是对象之间的通信、职责分配和算法封装。

第41章并发模式

Mon, 23 Mar 2026 08:39:00 +0800

第41章并发模式

Go语言从诞生之初就以"并发"为核心理念 goroutine 和 channel 的组合让并发编程变得前所未有的简单和优雅。

本章我们将探讨Go语言中常用的并发设计模式，这些模式能帮助你写出高效、可靠的并发程序。Go的并发哲学是：不要通过共享内存来通信，而是通过通信来共享内存。

基础部分 on 编程那些事儿

第1章 词法元素

第1章 词法元素

第2章 特殊指令与构建约束

第2章 特殊指令与构建约束

第3章 类型系统

第3章 类型系统

第4章 常量

第4章 常量

第5章 变量

第5章 变量

第6章 语句概述

第6章 语句概述

第7章 简单语句

第7章 简单语句

第8章 条件语句

第8章 条件语句

第9章 循环语句

第9章 循环语句

第10章 选择语句

第10章 选择语句

10.1 select 语句

10.1.1 select 语法

第11章 跳转语句

第11章 跳转语句

11.1 goto 语句

11.1.1 语法规则

第12章 数组

第12章 数组

12.1 数组类型

12.1.1 数组定义

第13章 切片

第13章 切片

第14章 map

第14章 map

第15章 结构体

第15章 结构体

第16章 函数类型

第16章 函数类型

第17章 函数

第17章 函数

第18章 方法

第18章 方法

第19章 接口类型

第19章 接口类型

第20章 接口实现

第20章 接口实现

第21章 接口值

第21章 接口值

第22章 类型断言

第22章 类型断言

22.1 断言语法

22.1.1 直接断言

22.1.2 comma-ok 断言

22.1.3 多个类型尝试

22.2 断言成功的情况

22.2.1 断言为具体类型

22.2.2 断言为接口类型

22.3 断言失败的情况

22.3.1 comma-ok断言安全处理

22.3.2 类型选择处理

22.4 断言与接口类型转换

22.4.1 接口转具体类型

本章小结

第23章 类型选择

第23章 类型选择

第24章 指针

第24章 指针

第25章 内存管理

第25章 内存管理

第26章 协程 Goroutine

第26章 协程 Goroutine

第27章 通道 Channel

第27章 通道 Channel

第28章 同步原语

第28章 同步原语

28.1 互斥锁 Mutex

28.1.1 为什么需要互斥锁

第29章 错误机制

第29章 错误机制

第1章词法元素

第1章词法元素

第2章特殊指令与构建约束

第2章特殊指令与构建约束

第3章类型系统

第3章类型系统

第4章常量

第4章常量

第5章变量

第5章变量

第6章语句概述

第6章语句概述

第7章简单语句

第7章简单语句

第8章条件语句

第8章条件语句

第9章循环语句

第9章循环语句

第10章选择语句

第10章选择语句

第11章跳转语句

第11章跳转语句

第12章数组

第12章数组

第13章切片

第13章切片

第15章结构体

第15章结构体

第16章函数类型

第16章函数类型

第17章函数

第17章函数

第18章方法

第18章方法

第19章接口类型

第19章接口类型

第20章接口实现

第20章接口实现

第21章接口值

第21章接口值

第22章类型断言

第22章类型断言

第23章类型选择

第23章类型选择

第24章指针

第24章指针

第25章内存管理

第25章内存管理

第26章协程 Goroutine

第26章协程 Goroutine

第27章通道 Channel

第27章通道 Channel

第28章同步原语

第28章同步原语

第29章错误机制

第29章错误机制

第30章异常机制

第30章异常机制

第31章包 Package

第31章包 Package

第32章模块 Module

第33章泛型 Generics

第34章反射 Reflect

第35章不安全编程 Unsafe

第35章不安全编程 Unsafe

第36章文档

第36章文档

第38章创建型模式

第38章创建型模式

第39章结构型模式

第39章结构型模式

第40章行为型模式

第40章行为型模式

第41章并发模式

第41章并发模式