技术分享

半小时掌握 Go 1.26

作者 itmax

2026年8月3日 2 分钟阅读

想真正熟练掌握一门编程语言，最有效的方法之一，就是大量阅读它的代码。

但问题是：

如果你连代码里的关键词、符号和语法含义都不了解，又怎么可能大量阅读呢？

所以这篇文章的目标很简单：

通过大量Go代码片段，快速理解Go语言中的核心语法、设计理念以及现代Go 1.26的最佳实践。

Go的魅力在于它的简单。

它没有复杂的继承体系，没有大量隐藏规则，也没有几十种完成同一件事情的方式。

Go希望开发者写出：

简单；

明确；

容易维护；

高性能；

适合工程实践的代码。

下面，我们用半小时快速过一遍Go 1.26最重要的知识点。

一个很香的 AI 平台：GPT-5.6 0.08 倍率和 Claude Code 4.8 只要 0.25倍率，包含 image-2生图。重点是首字请求都在 5s 内。入口：https://ai.aiyuhub.com

1. 变量声明：Go如何保存数据？

Go是一门静态类型语言。

也就是说：

每一个变量在编译阶段都有确定的数据类型。

例如：

var x int
x = 42

这里声明了一个整数变量。

如果只声明变量但没有赋值，Go会自动赋予它对应类型的零值。

例如：

var s string
var b bool
var p *int

它们默认分别是：

string → ""
bool   → false
pointer → nil

Go中有一个非常重要的概念：

零值设计。

很多情况下，你不需要手动初始化变量。

Go会保证变量拥有一个合理默认状态。

短变量声明

在函数内部，Go提供了更加简洁的写法：

x := 42
s := "hello"
f := 3.14
ok := true

编译器会自动推断类型：

x → int

s → string

f → float64

ok → bool

实际开发中：

函数内部优先使用 :=。

而 var 更适合：

包级变量；

需要明确类型；

希望从零值开始初始化的情况。

多变量赋值

Go支持一次给多个变量赋值：

a, b := 1, 2

a, b = b, a

第二行直接完成交换。

不需要传统语言里的临时变量：

temp = a
a = b
b = temp

空白标识符 `_`

Go要求所有声明的变量都必须被使用。

如果某个返回值你不需要：

可以使用 _ 丢弃。

例如：

value, _ := strconv.Atoi("42")

不过在生产代码中，不建议随意忽略错误。

错误处理是Go的重要设计之一。

2. 基础类型

Go提供了一组简单明确的数据类型。

类型	示例	零值
整数	int、int32、int64	0
浮点	float32、float64	0
字符串	string	“”
布尔	bool	false
字节	byte	0
Unicode字符	rune	0

通常情况下：

直接使用 int 即可。

Go会根据运行平台决定它的大小。

64位系统通常是64位整数。

32位系统通常是32位整数。

类型转换：Go不会偷偷帮你转换

Go没有隐式数字转换。

例如：

var i int = 42

var f float64 = float64(i)

必须明确告诉编译器：

我要把这个整数转换成浮点数。

这种设计减少了大量隐藏Bug。

常量和iota

常量使用：

const

声明。

例如：

const Pi = 3.14159
const Greeting = "hello"

Go还有一个非常方便的枚举工具：

iota

例如：

type Direction int

const (
    North Direction = iota
    East
    South
    West
)

结果：

North = 0
East  = 1
South = 2
West  = 3

非常适合定义状态、方向、类型编号等。

3. 函数：Go的核心组成

Go函数使用：

func

声明。

参数类型写在变量名后面。

例如：

func add(a, b int) int {
    return a + b
}

这和C语言、Java等语言的写法不同。

Go选择这种形式，是为了让声明更加统一。

没有返回值的函数

如果函数没有返回：

直接省略：

func greet(name string) {
    fmt.Printf("Hello, %s!", name)
}

可变参数函数

Go支持类似数组展开的参数。

例如：

func sum(nums ...int) int {
    total := 0

    for _, n := range nums {
        total += n
    }

    return total
}

调用：

sum(1,2,3)

结果：

也可以传入slice：

nums := []int{1,2,3}

sum(nums...)

三个点表示展开slice。

函数也是变量

Go中的函数是一等公民。

它可以：

保存到变量；

作为参数传递；

作为返回值。

例如：

double := func(x int) int {
    return x * 2
}

fmt.Println(double(5))

输出：

闭包

函数可以捕获外部变量。

例如：

func counter() func() int {
    n := 0

    return func() int {
        n++
        return n
    }
}

调用：

c := counter()

c()
c()
c()

结果：

1
2
3

这就是闭包。

defer：延迟执行

Go里面非常重要的关键词：

defer

它表示：

当前函数返回之前执行。

最常见用途：

资源释放。

例如：

f, err := os.Open(path)

if err != nil {
    return err
}

defer f.Close()

无论后面发生什么，函数退出时都会关闭文件。

另外：

多个defer按照LIFO顺序执行：

后添加的先执行。

4. 多返回值和错误处理

Go最经典的设计：

错误不是异常。

错误就是值。

例如：

func divide(a,b float64)(float64,error){

    if b == 0 {
        return 0, fmt.Errorf("cannot divide by zero")
    }

    return a/b,nil
}

调用：

result, err := divide(10,3)

if err != nil {
    log.Fatal(err)
}

Go要求你明确处理错误。

这也是Go代码看起来经常有：

if err != nil

的原因。

错误包装

Go支持错误链：

return fmt.Errorf(
    "reading config: %w",
    err,
)

之后可以：

errors.Is()

判断错误来源。

也可以：

errors.As()

提取具体错误类型。

5. 控制流程

if

Go没有括号：

if x > 0 {

}

但是大括号必须存在。

if初始化语句

非常常见：

if err := doSomething(); err != nil {
    return err
}

变量只存在于这个if范围内。

for：Go唯一循环

Go没有while关键字。

所有循环都是：

for

例如：

传统循环：

for i:=0;i<10;i++{

}

while效果：

for x < 100 {

}

无限循环：

for {

}

遍历数组：

for i,v := range list {

}

遍历map：

for k,v := range map {

}

Go 1.22之后：

还支持：

for i := range 5 {

}

输出：

0 1 2 3 4

6. Struct和方法

Go没有class。

结构体：

struct

承担数据组织作用。

例如：

type Point struct{
    X,Y float64
}

创建：

p := Point{
    X:3,
    Y:4,
}

方法

方法就是绑定到类型上的函数。

值接收：

func (p Point) Distance() float64

操作副本。

指针接收：

func (p *Point) Scale(f float64)

可以修改原对象。

Go建议：

如果一个类型的方法使用指针接收者，最好全部统一使用指针接收者。

避免混乱。

7. Interface：Go最核心的抽象

Go接口非常特殊。

没有：

implements

关键字。

只要一个类型拥有接口要求的方法，它自动满足接口。

例如：

type Shape interface{
    Area() float64
}

Rectangle实现：

func(r Rectangle)Area()float64{
    return r.W*r.H
}

它自动就是Shape。

这就是Go著名的：

隐式接口。

8. 指针和new()

指针保存地址。

x :=42

p := &x

fmt.Println(*p)

输出：

修改：

*p=100

x也会改变。

Go 1.26新增：

new()现在支持表达式。

以前：

age := yearsSince(born)

p := Person{
    Age:&age,
}

现在：

p := Person{
    Age:new(yearsSince(born)),
}

更加简洁。

这对于JSON、Protobuf中大量可选指针字段非常方便。

9. Slice和Map

Slice是Go最常用的数据结构。

它不是数组。

而是：

数组视图。

包含：

指针；
长度；
容量。

例如：

s:=[]int{1,2,3}

s=append(s,4,5)

结果：

[1 2 3 4 5]

提前分配：

make([]int,0,100)

可以减少扩容带来的复制成本。

Map：

m:=map[string]int{
    "alice":90,
}

读取：

score:=m["alice"]

判断是否存在：

score,ok:=m["bob"]

注意：

Go的map遍历顺序是不固定的。

不要依赖顺序。

10. Goroutine和Channel

Go最强大的特性之一：

并发。

启动goroutine：

go sayHello()

它比操作系统线程轻量很多。

Channel用于goroutine之间通信。

Go理念：

不要通过共享内存通信，而应该通过通信共享内存。

发送：

ch<-42

接收：

v:=<-ch

关闭：

close(ch)

真实场景：

多个HTTP请求并发执行：

请求1 → goroutine

请求2 → goroutine

请求3 → goroutine

        ↓

     channel

        ↓

    汇总结果

11. Generics泛型

Go 1.18加入泛型。

例如：

func Map[T,U any](
    s []T,
    f func(T)U,
)[]U

可以处理不同类型。

Go 1.26新增：

自引用泛型约束。

以前限制：

泛型类型不能在自己的类型参数列表里引用自己。

现在解除。

例如：

type Adder[A Adder[A]] interface{
    Add(A)A
}

这让一些高级泛型模式成为可能。

12. Package和Module

Go文件属于package。

导出的标识符：

首字母大写。

例如：

func Add()

外部可以访问。

小写：

func helper()

只能内部使用。

创建模块：

go mod init github.com/you/myapp

整理依赖：

go mod tidy

Go 1.26：

go fix 被重新设计。

现在它成为官方代码现代化工具：

go fix ./...

可以自动升级代码风格和API使用方式。

13. 测试

Go测试文件：

必须：

_test.go

例如：

func TestAdd(t *testing.T){

}

Go最推荐：

表驱动测试。

例如：

tests:=[]struct{
    name string
    a,b int
    want int
}{
    {"positive",2,3,5},
    {"zero",0,0,0},
}

常用命令：

go test ./...

go test -cover ./...

go test -bench=.

go test -race ./...

CI环境建议开启：

-race

检测竞态问题。

14. Go工具链

常用命令：

go build ./...

go run main.go

go test ./...

go vet ./...

go fix ./...

go doc fmt.Println

go env

格式化：

gofmt -w .

Go世界里：

格式没有争论。

gofmt就是规则。

Go 1.26的重要变化

Go 1.26带来了几个值得关注的更新：

Green Tea GC成为默认垃圾回收器

新的GC优化了小对象标记和扫描效率。

对于大量分配对象的程序：

GC开销预计降低10%~40%。

现代CPU还能利用向量指令进一步提升性能。

开发者无需修改代码，升级版本即可获得收益。

最后：Go为什么值得学习？

Go刻意保持简单。

它的语言规范非常小。

但标准库非常强大。

网络；

JSON；

加密；

测试；

并发；

服务端开发。

这些工程场景都被很好支持。

随着Go 1.26带来的：

新GC；
更智能的go fix；
new()改进；
泛型增强；

现在依然是学习和使用Go非常好的时间。

真正掌握Go，不是记住所有语法。

而是理解它背后的设计哲学：

简单优先。

明确优先。

工程优先。

这也是为什么Go能够成为云原生、后端服务和基础设施领域的重要语言。

https://segmentfault.com/a/1190000048107951

itmax

其他文章

AI Native 交易核心系统的研发范式｜得物技术

FFmpeg 9.0正式发布：代号“Lei”，以纪念中国开发者雷霄骅

暂无评论！成为第一个。

发表回复取消回复