Go（又称 Golang）是 Google 于 2009 年正式发布的开源编程语言。它由 Ken Thompson（Unix 创始人之一）、Rob Pike（Unix 团队成员）和 Robert Griesemer 共同设计。Go 语言的设计目标是解决大规模软件开发中的实际问题，特别是在 Google 这样的大型互联网公司中遇到的并发、编译速度和代码维护等挑战。
Go 语言的设计哲学可以概括为：简单、高效、可靠。
Go 语言核心理念
├── 简洁性
│ ├── 语法简单，关键字仅 25 个
│ ├── 没有类继承、泛型（1.18 前）、异常等复杂特性
│ └── 代码风格统一（gofmt 强制格式化）
├── 高效性
│ ├── 编译速度极快
│ ├── 运行效率接近 C/C++
│ └── 内置垃圾回收（GC）
└── 并发性
├── Goroutine 轻量级协程
├── Channel 通信机制
└── 天生适合高并发场景
Go 是一门强类型静态语言，所有变量在编译时确定类型。Go 的类型系统简洁而强大，不支持隐式类型转换，这使得代码更加安全可靠。
Go 类型体系
├── 基本类型（Basic Types）
│ ├── 布尔型：bool
│ ├── 整数型：int, int8, int16, int32, int64
│ │ uint, uint8, uint16, uint32, uint64, uintptr
│ ├── 浮点型：float32, float64
│ ├── 复数型：complex64, complex128
│ ├── 字符型：byte(uint8), rune(int32)
│ └── 字符串：string
├── 复合类型（Composite Types）
│ ├── 数组：[N]T
│ ├── 切片：[]T
│ ├── 映射：map[K]V
│ └── 结构体：struct
├── 引用类型（Reference Types）
│ ├── 指针：*T
│ ├── 切片：[]T
│ ├── 映射：map[K]V
│ ├── 通道：chan T
│ └── 函数：func
└── 接口类型（Interface Types）
├── interface{}（空接口，Go 1.18 前）
└── any（Go 1.18+ 空接口别名）
Go 的 if 语句无需括号包围条件表达式，但花括号是必须的：
package main
import (
"fmt"
"os"
"runtime"
)
func main() {
// 基本形式
x := 10
if x > 5 {
fmt.Println("x 大于 5")
}
// if-else
if x%2 == 0 {
fmt.Println("x 是偶数")
} else {
fmt.Println("x 是奇数")
}
// if-else if-else
score := 85
if score >= 90 {
fmt.Println("优秀")
} else if score >= 80 {
fmt.Println("良好")
} else if score >= 60 {
fmt.Println("及格")
} else {
fmt.Println("不及格")
}
// ========== if 简短语句（Go 特有）==========
// 可以在条件之前执行一个简单语句
// 该语句声明的变量只在 if 块内可用
if err := doSomething(); err != nil {
fmt.Println("操作失败:", err)
return
}
// 常见的错误处理模式
if data, err := os.ReadFile("/etc/hostname"); err != nil {
fmt.Println("读取失败:", err)
} else {
fmt.Printf("主机名: %s", data)
}
// 运维场景：系统检查
if mem := runtime.MemStats{}; true {
runtime.ReadMemStats(&mem)
allocMB := float64(mem.Alloc) / 1024 / 1024
if allocMB > 100 {
fmt.Printf("警告: 内存使用 %.2f MB\n", allocMB)
}
}
}
func doSomething() error {
return nil
}
数组是固定长度、同类型元素的序列。在 Go 中，数组长度是类型的一部分。
package main
import "fmt"
func main() {
// ========== 数组声明 ==========
// 方式一：指定长度和类型
var arr1 [5]int // [0, 0, 0, 0, 0]
// 方式二：声明并初始化
var arr2 = [5]int{1, 2, 3, 4, 5}
// 方式三：短声明
arr3 := [5]int{1, 2, 3} // [1, 2, 3, 0, 0]
// 方式四：自动推断长度
arr4 := [...]int{1, 2, 3, 4, 5} // 长度为 5
// 方式五：指定索引初始化
arr5 := [5]string{1: "one", 3: "three"} // ["", "one", "", "three", ""]
fmt.Println(arr1, arr2, arr3, arr4, arr5)
// ========== 数组操作 ==========
// 访问元素
fmt.Println("arr2[0] =", arr2[0])
// 修改元素
arr2[0] = 100
fmt.Println("修改后:", arr2)
// 获取长度
fmt.Println("长度:", len(arr2))
// ========== 数组遍历 ==========
servers := [3]string{"web-01", "web-02", "web-03"}
// for 循环
for i := 0; i < len(servers); i++ {
fmt.Printf("servers[%d] = %s\n", i, servers[i])
}
// range 遍历
for index, value := range servers {
fmt.Printf("[%d] %s\n", index, value)
}
// ========== 多维数组 ==========
matrix := [3][3]int{
{1, 2, 3},
{4, 5, 6},
{7, 8, 9},
}
fmt.Println("矩阵:")
for _, row := range matrix {
fmt.Println(row)
}
// ========== 数组是值类型 ==========
original := [3]int{1, 2, 3}
copied := original // 完整复制
copied[0] = 100
fmt.Println("original:", original) // [1, 2, 3]（未变）
fmt.Println("copied:", copied) // [100, 2, 3]
}
Go 语言没有传统的类（class）和继承（inheritance），而是通过组合（composition）和接口（interface）实现面向对象编程。
传统 OOP vs Go OOP
├── 传统语言（Java/C++/Python）
│ ├── class 定义类
│ ├── extends 继承
│ ├── implements 显式实现接口
│ ├── abstract 抽象类
│ └── private/protected/public 访问控制
│
└── Go 语言
├── struct 定义类型
├── 嵌入（embedding）代替继承
├── 隐式接口实现
├── 没有抽象类（使用接口代替）
└── 大小写控制可见性
Go 语言采用显式错误处理机制，而非传统的 try-catch 异常处理。这种设计强调：
Go 错误处理 vs 传统异常处理
├── 传统异常处理（Java/Python/C++）
│ ├── try-catch-finally 块
│ ├── 异常可以跨层传播
│ ├── 容易忽略错误处理
│ └── 性能开销（栈展开）
│
└── Go 错误处理
├── 错误作为返回值
├── 调用方必须显式处理
├── 代码逻辑清晰
└── panic/recover 仅用于真正的异常
Go 语言的并发是其最强大的特性之一。Go 采用 CSP（Communicating Sequential Processes）并发模型。
Go 并发模型
├── Goroutine（轻量级线程）
│ ├── 初始栈仅 2KB（线程通常 1-8MB）
│ ├── Go 运行时管理调度
│ ├── 创建成本极低
│ └── 可轻松创建数十万个
├── Channel（通道）
│ ├── Goroutine 间通信
│ ├── 类型安全
│ ├── 支持缓冲和非缓冲
│ └── 可用于同步
├── GMP 调度模型
│ ├── G - Goroutine
│ ├── M - Machine（OS 线程）
│ ├── P - Processor（逻辑处理器）
│ └── 默认 P 数量 = CPU 核数
└── 核心理念
└── "不要通过共享内存来通信，而要通过通信来共享内存"
context.Context 是 Go 并发编程的核心工具，用于传递取消信号、超时控制和请求级数据。
Context 层级关系
Background（根 Context）
├── WithCancel → 手动取消
├── WithDeadline → 截止时间
├── WithTimeout → 超时时间
└── WithValue → 传递数据
├── 子 Context 1
│ └── 子 Context 1.1
└── 子 Context 2
Go 标准库功能丰富，覆盖大部分开发需求，是 Go 生态的核心优势。
运维常用标准库
├── 基础处理
│ ├── fmt - 格式化 I/O
│ ├── strings - 字符串操作
│ ├── strconv - 字符串转换
│ ├── regexp - 正则表达式
│ └── unicode - Unicode 处理
├── 系统操作
│ ├── os - 操作系统功能
│ ├── os/exec - 执行外部命令
│ ├── path/filepath - 文件路径处理
│ └── runtime - 运行时信息
├── I/O 操作
│ ├── io - I/O 原语
│ ├── io/fs - 文件系统接口
│ ├── bufio - 缓冲 I/O
│ └── embed - 嵌入静态文件
├── 时间日期
│ └── time - 时间处理
├── 数据格式
│ ├── encoding/json - JSON
│ ├── encoding/xml - XML
│ ├── encoding/csv - CSV
│ └── encoding/base64 - Base64
├── 网络相关
│ ├── net - 网络原语
│ ├── net/http - HTTP 客户端/服务端
│ └── net/url - URL 解析
├── 日志调试
│ ├── log - 日志
│ └── log/slog - 结构化日志（Go 1.21+）
├── 加密安全
│ ├── crypto/* - 加密算法
│ └── hash/* - 哈希算法
└── 数据结构
├── container/list - 双向链表
├── container/heap - 堆
└── container/ring - 环形链表
package main
import (
"bufio"
"fmt"
"io"
"net"
"time"
)
func main() {
// 监听端口
listener, err := net.Listen("tcp", ":8080")
if err != nil {
fmt.Println("监听失败:", err)
return
}
defer listener.Close()
fmt.Println("TCP 服务器启动在 :8080")
for {
// 接受连接
conn, err := listener.Accept()
if err != nil {
fmt.Println("接受连接失败:", err)
continue
}
// 处理连接（每个连接一个 goroutine）
go handleConnection(conn)
}
}
func handleConnection(conn net.Conn) {
defer conn.Close()
clientAddr := conn.RemoteAddr().String()
fmt.Printf("[%s] 新连接\n", clientAddr)
// 设置读取超时
conn.SetReadDeadline(time.Now().Add(5 * time.Minute))
reader := bufio.NewReader(conn)
for {
// 读取一行数据
line, err := reader.ReadString('\n')
if err != nil {
if err == io.EOF {
fmt.Printf("[%s] 连接关闭\n", clientAddr)
} else {
fmt.Printf("[%s] 读取错误: %v\n", clientAddr, err)
}
return
}
fmt.Printf("[%s] 收到: %s", clientAddr, line)
// 回显
response := fmt.Sprintf("服务器收到: %s", line)
conn.Write([]byte(response))
}
}