数组 | Tony Bai

标签数组下的文章

评点2021-2022年上市的那些Go语言新书

六月 1, 2022
5 条评论

本文永久链接 – https://tonybai.com/2022/06/01/reviewing-those-new-go-language-books-coming-out-in-2021-2022

计算机科学与技术这个工业大类与传统工业类别相比还很“年轻”，并且由于历史原因，整个计算机科学与技术学科的奠基都是由欧美人完成的，因此但凡诞生一门新IT技术或新编程语言，我们首先参考的都是来自欧美的外文技术书籍(影印或翻译)。

以Go为例，笔者最先接触的Go技术书籍资料是《The Way To Go》：

这也是笔者早期学习Go语言时最喜欢翻看的一本书，也是我目前见到的、最全面详实的讲解Go语言的书籍了，可以说是Gopher们的第一本“Go语言百科全书”。可能是由于这本书出版太早了，等国内出版社意识到要引进Go语言方面的书籍的时候，这本书使用的Go版本已经太老了。不过，这本书中绝大部分例子依然可以在今天最新的Go编译器下通过编译并运行起来。

另外一本不得不提的就是由K&R C中的K：Brian W. Kernighan老爷子参与编写的《The Go Programming Language》：

这本书模仿并致敬《The C Programming Language》的经典结构，从一个”hello, world”示例开始带领大家开启Go语言之旅。作者行文十分精炼，字字珠玑，这与《The C Programming Language》的风格保持了高度一致。而且，书中的示例在浅显易懂的同时，又极具实用性，还突出Go语言的特点（比如并发web爬虫、并发非阻塞的缓存系统等）。读完这本书后，你会有一种爱不释手，马上还要从头再读一遍的感觉，这也许这就是“Go语言圣经”的魅力吧！

不过，随着Go语言在国内的扎根和广泛应用，国内接纳Go较早的一批Gopher以及国内大厂“身经百战”的Gopher开始将Go语言沉淀下来，并陆续上线了自己的作品。从2020年开始，国内作者出版的Go语言相关书籍已经逐渐多了起来，并且质量也在逐渐提升。就像我在《Go语言第一课》的加餐文章《我“私藏”的那些优质且权威的Go语言学习资料》中预测的那样：将有更多Gopher加入Go技术书籍的写作行列，从2021开始的3年，国内Go语言技术书籍也会迎来一波小高峰。

618购物节前夕，我就来简单评点一下2021年至今出版的口碑还不错的Go语言新书(按出版时间顺序)，大家可以趁打折力度较大的窗口按需从电商平台购买纸版书或电子书渠道购买电子书阅读^_^。

1. 《Go语言底层原理剖析》 2021.8

Go语言是带有GC与运行时的语言，这就意味着很多东西不是“表面”看到的那样，比如string、切片、map等类型在运行时的表示与我们在源码中看到的有很大不同。要想玩转Go语言，不下沉到“原理”这一层还真不行。

《Go语言底层原理剖析》这本书显然也是定位了那些对Go原理有述求的这部分gopher群体。书的作者郑建勋老师是滴滴的高级研发工程师。大家知道，滴滴公司内部使用Go技术栈实现的服务比例是很高的，因此这本书也是郑老师在滴滴“摸爬滚打”后的实践检验的沉淀与总结。

这本书从Go编译构建原理起步，然后过渡到Go的几种常见复合类型(数组、字符串、切片、map)的实现原理的讲解，再到对Go核心语法函数、接口、异常处理的原理说明，最后是Go的精华，也是最难啃的部分：goroutine调度、内存分配与GC。如果从覆盖的内容全面性上，应该说基本都包含到了。

笔者在微信读书上对整本书做了阅读，从阅读体验来看，郑老师的技术十分扎实，讲解也很到位。美中不足的是，有些内容刚刚引发你想继续深入的兴趣时，书籍内容却在这里戛然而止了。如果能继续展开就更好了，也许这是基于书籍篇幅上的考量。

✩豆瓣评分：8.5
✩微信读书推荐值：57.7%

本书在豆瓣口碑与微信读书推荐上存在一些分化，原因这个还不得而知。

2. 《Go语言设计与实现》 2021.11

《Go语言设计与实现》一书是作者左书祺(Draven)在其同名开源电子书《Go语言设计与实现》的基础上进一步系统整理和丰富而成。左老师的开源电子书在国内Gopher圈内有着相当好的口碑，他擅长以精美插图的方式对技术细节进行细致入微的讲解，作者甚至还专门出过一篇《技术文章配图指南》来说明其文章中插图制作使用的工具以及方法。

和《Go语言底层原理剖析》一样，《Go语言设计与实现》同样聚焦在Go编译器、类型系统与运行机制的原理层面，两本书对原理的说明角度和风格各有特点，就看读者喜欢哪种。更好的方法是主题阅读，两个相互参照的看。

编写面向Go底层原理的书是有一定“风险”的，很容易随着时间的流逝而变得“outdated”，这是因为Go语言还在快速演进中，其底层实现也在不断变化，远没有Java那样成熟，所以很难像神作《深入理解java虚拟机》那般“稳定”，需要不断更新。在这一点上，纸板书反倒没有开源电子书优势明显，后者可做到以快速持续的迭代更新。

不过笔者觉得：要想对一个语言机制的底层原理理解透彻，光是掌握其当前的实现机制还不够，了解其实现机制的历史演进过程将大有裨益，而上面的两本书的价值恰恰还可以体现在这个方面，尤其是当书中的实现机制在将来过时的时候。

✩豆瓣评分：8.5
✩微信读书推荐值：未上架

3. 《Go语言精进之路》 2021.12.17

写Go语言语法方面的书风险小，Go书籍的寿命都很长，这是因为Go1兼容性承诺的存在，这也是Go书籍作者的幸运。

《Go语言精进之路》是笔者的作品，该作品主要面向一个刚刚Go入门后的Go新手，就像副标题描述的那样，聚焦于告诉一个Go入门新手如何能像Go开发团队那样写出符合Go思维和语言惯例的高质量代码。书中也有一部分底层原理的介绍，但这些介绍也都是为了配合主线的讲解。由于是偏思维、方法与技巧方面的讲解，里面的绝大部分知识点，即使是几年后，依然是有效的。这就像出版于2015年的Go语言圣经《The Go Programming language》目前看毫不过时一样。

笔者自己的书不好自作点评，下面是近期一位读者在weibo上主动at我的评价：

其他评价/评论大家也可以在书籍的豆瓣页面或微信读书页面上自行查看。

✩豆瓣评分：8.9
✩微信读书推荐值：84.1%

4. 《Go语言定制指南》 2022.2.1

《Go语言定制指南》是国内Go技术专家柴树衫老师既《Go语言高级编程》后的又一力作，这次内容更加聚焦：围绕Go语法分析树学习Go词法分析、语法分析、语义分析以及中间代码生成的原理，并基于Go语法树对Go语言进行二次改造，基于Go语言语法裁剪出一个极小子集——凹语言，并实现其的解释执行。

更具体来说，书中主要讲解的是go/ast和go/types等Go编译器相关包的用法，比如：结合Go语言的文法、语法与go/ast包输出的语法树的对应关系；使用go/types进行语义检查的方法等。

这也是目前国内第一本以Go编译器前端为中心的Go语言技术书籍，即便放眼全世界，这也是稀有的。如果你对Go编译器的工作原理、对定制Go语言十分感兴趣，那么此书是你的不二之选。

不过编译器和语言开发是门槛较高的领域，不免会出现“曲高和寡”的境遇，这本书注定是本已是小众的Go社区中的小众群体的菜。

✩豆瓣评分：暂无
✩微信读书推荐值：暂无

5. 引进版新书简评

在豆瓣图书搜索Go技术书籍，看到下面几本刚刚出版不久(可能尚未上架)以及即将出版的几本引进版的新书，这里顺便说说。

《Go语言学习指南：惯例模式与编程实践》 2022.4.29

这是O’Reilly出版社于2021年3月出版的《Learning Go: An Idiomatic Approach to Real-World Go Programming》的中译版，中文版我还没有来得及读，不过原版我是粗略读过的。这本书面向Go入门群体，同时结合一些实战的例子，与《The Go Programming Language》的受众群体相似度很高。

这本书(原版)整体质量很高，语言精炼，讲解全面，更重要的是它似乎也是第一个包含Go泛型内容的Go入门书，只不过出版时，Go泛型尚未正式发布。今年3月份Go 1.18泛型落地后，该书作者还对泛型章节做了修订，并在网上提供电子版供读者下载。

《用Go语言自制解释器》和《用Go语言自制编译器》 2022.6.1

这两本都是索斯藤·鲍尔（Thorsten Ball）在2018年自出版的书！作者使用Go语言手把手教你实现了一门类C语法的Monkey语言，从词法分析、语法分析、建立语法树并进行语法分析，到生成字节码，并实现可以执行该字节码的虚拟机，实现Monkey语言的真实执行。这本书在国外颇受好评。

作者在书中采用的是手写词法分析器和语法分析器的方式，而不是借助像ANTLR这样的parser生成工具，这可以让读者更加深刻的理解和认知一门编程语言的实现过程，酷感十足。

6. 小结

我们看到，2021年来出品的Go技术书籍都获得了不错的口碑，这也说明国内Go语言的整体水准在提升，对于刚刚加入Go社区的小伙伴们，这是真金白银般的好消息，看好书可以避免走弯路，节省大量时间与精力！

挑一本适合你的，该出手时就出手吧！

注意：以上豆瓣评分与微信读书推荐值都是2022.5.31的快照值，不代表后续不会发生变化。

“Gopher部落”知识星球旨在打造一个精品Go学习和进阶社群！高品质首发Go技术文章，“三天”首发阅读权，每年两期Go语言发展现状分析，每天提前1小时阅读到新鲜的Gopher日报，网课、技术专栏、图书内容前瞻，六小时内必答保证等满足你关于Go语言生态的所有需求！2022年，Gopher部落全面改版，将持续分享Go语言与Go应用领域的知识、技巧与实践，并增加诸多互动形式。欢迎大家加入！

img{512x368}

我爱发短信：企业级短信平台定制开发专家 https://tonybai.com/。smspush : 可部署在企业内部的定制化短信平台，三网覆盖，不惧大并发接入，可定制扩展；短信内容你来定，不再受约束, 接口丰富，支持长短信，签名可选。2020年4月8日，中国三大电信运营商联合发布《5G消息白皮书》，51短信平台也会全新升级到“51商用消息平台”，全面支持5G RCS消息。

著名云主机服务厂商DigitalOcean发布最新的主机计划，入门级Droplet配置升级为：1 core CPU、1G内存、25G高速SSD，价格5$/月。有使用DigitalOcean需求的朋友，可以打开这个链接地址：https://m.do.co/c/bff6eed92687 开启你的DO主机之路。

Gopher Daily(Gopher每日新闻)归档仓库 – https://github.com/bigwhite/gopherdaily

我的联系方式：

微博：https://weibo.com/bigwhite20xx
博客：tonybai.com
github: https://github.com/bigwhite

商务合作方式：撰稿、出书、培训、在线课程、合伙创业、咨询、广告合作。

针对大型数组的迭代，for range真的比经典for loop慢吗？

三月 19, 2022
0 条评论

本文永久链接 – https://tonybai.com/2022/03/19/for-range-vs-classic-for-loop-when-iterating-large-array

Go语言推崇“一件事情仅有一个作法”！比如：Go仅保留一类循环控制语句，那就是经典版的for loop：

for i := 0; i < 100; i++ {
    ... ...
}

而像C语言支持的while、do…while等循环控制语句都被排除在Go简洁的语法之外。但为了方便Go开发者对复合数据类型的迭代，比如：数组、切片、channel以及map等，Go提供了一个变种for range loop，甚至对于map、channel进行遍历，仅能使用for range loop，经典版for loop根本不支持。

不过for range 带来了方便的同时，也给Go初学者带来了一些烦恼，比如：for range迭代复合类型变量时就有一些常见的且十分容易掉入的“坑”，这些“坑”我在《Go语言第一课》中有全面详细的讲解。这里为了给后面的内容做铺垫，只提一个for range的坑，那就是参与循环的是range表达式的副本。

我们来看一个专栏中的例子：

func main() {
    var a = [5]int{1, 2, 3, 4, 5}
    var r [5]int

    fmt.Println("original a =", a)

    for i, v := range a {
        if i == 0 {
            a[1] = 12
            a[2] = 13
        }
        r[i] = v
    }

    fmt.Println("after for range loop, r =", r)
    fmt.Println("after for range loop, a =", a)
}

大家来猜猜这段代码会输出什么结果？你是不是觉得这段代码会输出如下结果：

original a = [1 2 3 4 5]
after for range loop, r = [1 12 13 4 5]
after for range loop, a = [1 12 13 4 5]

但实际运行该程序的输出结果却是：

original a = [1 2 3 4 5]
after for range loop, r = [1 2 3 4 5]
after for range loop, a = [1 12 13 4 5]

我们原以为在第一次迭代过程，也就是i = 0时，我们对a的修改 (a[1] =12,a[2] = 13) 会在第二次、第三次迭代中被v取出，但从结果来看，v 取出的依旧是a被修改前的值：2和3。

为什么会是这种情况呢？原因就是参与for range循环的是range表达式的副本。也就是说，在上面这个例子中，真正参与循环的是a的副本，而不是真正的a。

为了方便你理解，我们将上面的例子中的for range循环，用一个等价的伪代码形式重写一下：

for i, v := range a' { //a'是a的一个值拷贝
    if i == 0 {
        a[1] = 12
        a[2] = 13
    }
    r[i] = v
}

现在真相终于揭开了：这个例子中，每次迭代的都是从数组a的值拷贝a’中得到的元素。a’是Go临时分配的连续字节序列，与a完全不是一块内存区域。因此无论a被如何修改，它参与循环的副本a’依旧保持原值，因此v从a’中取出的仍旧是a的原值，而不是修改后的值。

好了，问题来了(来自专栏的一位童鞋的留言)！

这位童鞋的核心问题就一个：对于大型数组，由于参与for range的是该数组的拷贝，那么使用for range是不是会比经典for loop更耗资源且性能更差？

我们通过benchmark例子来验证一下：针对大型数组，for range是不是一定就比经典for loop跑得更慢？我们先看第一个例子：

// benchmark1_test.go

package main

import "testing"

func BenchmarkClassicForLoopIntArray(b *testing.B) {
    b.ReportAllocs()
    var arr [100000]int
    for i := 0; i < b.N; i++ {
        for j := 0; j < len(arr); j++ {
            arr[j] = j
        }
    }
}

func BenchmarkForRangeIntArray(b *testing.B) {
    b.ReportAllocs()
    var arr [100000]int
    for i := 0; i < b.N; i++ {
        for j, v := range arr {
            arr[j] = j
            _ = v
        }
    }
}

在这个例子中，我们分别用for loop与for range对一个拥有10w个int类型元素的数组进行遍历，我们看看benchmark的结果：

// Go 1.18rc1, MacOS
$go test -bench . benchmark1_test.go
goos: darwin
goarch: amd64
cpu: Intel(R) Core(TM) i5-8257U CPU @ 1.40GHz
BenchmarkClassicForLoopIntArray-8          22080         55124 ns/op           0 B/op          0 allocs/op
BenchmarkForRangeIntArray-8                34808         34433 ns/op           0 B/op          0 allocs/op
PASS
ok      command-line-arguments  3.321s

从输出结果我们看到：for range loop非但未受到large array拷贝操作的影响，其性能居然比for range loop的性能还要好，这显然是在编译器层面(通常是静态单一赋值，即SSA环节)做了优化的结果。

我们关闭优化开关，再运行一下压测：

$go test -c -gcflags '-N -l' .
$./demo.test -test.bench .
goos: darwin
goarch: amd64
pkg: demo
cpu: Intel(R) Core(TM) i5-8257U CPU @ 1.40GHz
BenchmarkClassicForLoopIntArray-8           6248        187773 ns/op           0 B/op          0 allocs/op
BenchmarkForRangeIntArray-8                 4768        246512 ns/op           0 B/op          0 allocs/op
PASS

我们看到：在没有优化的情况下，两种loop的性能都大幅下降，并且for range下降更多，性能显著不如经典for loop。你可以对比一下BenchmarkForRangeIntArray函数在正常优化(go tool compile -S xxx.go)以及关闭优化时(go tool compile -S -N -l)的汇编代码片段，你会发现关闭优化后，汇编代码使用了很多中间变量存储中间结果，而优化后的代码则消除了这些中间状态。

那么接下来你可能会提出这样一个问题：是不是for range迭代任何元素类型的大型数组，其性能都不比经典for loop差呢？我们来看一个对结构体数组遍历的例子：

// benchmark3_test.go
package main

import "testing"

type U5 struct {
    a, b, c, d, e int
}
type U4 struct {
    a, b, c, d int
}
type U3 struct {
    b, c, d int
}
type U2 struct {
    c, d int
}
type U1 struct {
    d int
}

func BenchmarkClassicForLoopLargeStructArrayU5(b *testing.B) {
    b.ReportAllocs()
    var arr [100000]U5
    for i := 0; i < b.N; i++ {
        for j := 0; j < len(arr)-1; j++ {
            arr[j].d = j
        }
    }
}
func BenchmarkClassicForLoopLargeStructArrayU4(b *testing.B) {
    b.ReportAllocs()
    var arr [100000]U4
    for i := 0; i < b.N; i++ {
        for j := 0; j < len(arr)-1; j++ {
            arr[j].d = j
        }
    }
}
func BenchmarkClassicForLoopLargeStructArrayU3(b *testing.B) {
    b.ReportAllocs()
    var arr [100000]U3
    for i := 0; i < b.N; i++ {
        for j := 0; j < len(arr)-1; j++ {
            arr[j].d = j
        }
    }
}
func BenchmarkClassicForLoopLargeStructArrayU2(b *testing.B) {
    b.ReportAllocs()
    var arr [100000]U2
    for i := 0; i < b.N; i++ {
        for j := 0; j < len(arr)-1; j++ {
            arr[j].d = j
        }
    }
}

func BenchmarkClassicForLoopLargeStructArrayU1(b *testing.B) {
    b.ReportAllocs()
    var arr [100000]U1
    for i := 0; i < b.N; i++ {
        for j := 0; j < len(arr)-1; j++ {
            arr[j].d = j
        }
    }
}

func BenchmarkForRangeLargeStructArrayU5(b *testing.B) {
    b.ReportAllocs()
    var arr [100000]U5
    for i := 0; i < b.N; i++ {
        for j, v := range arr {
            arr[j].d = j
            _ = v
        }
    }
}
func BenchmarkForRangeLargeStructArrayU4(b *testing.B) {
    b.ReportAllocs()
    var arr [100000]U4
    for i := 0; i < b.N; i++ {
        for j, v := range arr {
            arr[j].d = j
            _ = v
        }
    }
}

func BenchmarkForRangeLargeStructArrayU3(b *testing.B) {
    b.ReportAllocs()
    var arr [100000]U3
    for i := 0; i < b.N; i++ {
        for j, v := range arr {
            arr[j].d = j
            _ = v
        }
    }
}
func BenchmarkForRangeLargeStructArrayU2(b *testing.B) {
    b.ReportAllocs()
    var arr [100000]U2
    for i := 0; i < b.N; i++ {
        for j, v := range arr {
            arr[j].d = j
            _ = v
        }
    }
}
func BenchmarkForRangeLargeStructArrayU1(b *testing.B) {
    b.ReportAllocs()
    var arr [100000]U1
    for i := 0; i < b.N; i++ {
        for j, v := range arr {
            arr[j].d = j
            _ = v
        }
    }
}

在这个例子中，我们定义了5种结构体：U1~U5，它们的不同之处就在于包含的int类型字段的个数不同。我们分别用经典for loop与for range loop对以这些类型为元素的大型数组进行遍历，看看结果如何：

$go test -bench . benchmark3_test.go
goos: darwin
goarch: amd64
cpu: Intel(R) Core(TM) i5-8257U CPU @ 1.40GHz
BenchmarkClassicForLoopLargeStructArrayU5-8        22030         54116 ns/op           0 B/op          0 allocs/op
BenchmarkClassicForLoopLargeStructArrayU4-8        22131         54145 ns/op           0 B/op          0 allocs/op
BenchmarkClassicForLoopLargeStructArrayU3-8        22257         54001 ns/op           0 B/op          0 allocs/op
BenchmarkClassicForLoopLargeStructArrayU2-8        22063         54580 ns/op           0 B/op          0 allocs/op
BenchmarkClassicForLoopLargeStructArrayU1-8        22105         54408 ns/op           0 B/op          0 allocs/op
BenchmarkForRangeLargeStructArrayU5-8               3022        391232 ns/op           0 B/op          0 allocs/op
BenchmarkForRangeLargeStructArrayU4-8               4563        265919 ns/op           0 B/op          0 allocs/op
BenchmarkForRangeLargeStructArrayU3-8               6602        182224 ns/op           0 B/op          0 allocs/op
BenchmarkForRangeLargeStructArrayU2-8              10000        111966 ns/op           0 B/op          0 allocs/op
BenchmarkForRangeLargeStructArrayU1-8              35380         34005 ns/op           0 B/op          0 allocs/op
PASS
ok      command-line-arguments  15.907s

我们看到一个奇怪的现象：无论是哪种结构体类型，经典for loop遍历的性能都是一样的，但for range的遍历性能却会随着结构体字段数量的增多而下降。

带着疑惑，我找到了与这个问题有关的一个issue：cmd/compile: optimize large structs，这个issue大致是说对于包含特定数量字段的结构体类型，目前是unSSAable，如果不能SSA，那么就无法通过SSA优化，这也是出现上述benchmark结果的重要原因。

在Go中，几乎所有使用数组的地方都可以用切片替代，笔者还是建议尽量用迭代切片替换对数组的迭代，这样总是可以取得一致且稳定的遍历性能。

img{512x368}

Gopher Daily(Gopher每日新闻)归档仓库 – https://github.com/bigwhite/gopherdaily

我的联系方式：

微博：https://weibo.com/bigwhite20xx
微信公众号：iamtonybai
博客：tonybai.com
github: https://github.com/bigwhite
“Gopher部落”知识星球：https://public.zsxq.com/groups/51284458844544

商务合作方式：撰稿、出书、培训、在线课程、合伙创业、咨询、广告合作。

标签数组下的文章

评点2021-2022年上市的那些Go语言新书

1. 《Go语言底层原理剖析》 2021.8

2. 《Go语言设计与实现》 2021.11

3. 《Go语言精进之路》 2021.12.17

4. 《Go语言定制指南》 2022.2.1

5. 引进版新书简评

6. 小结

针对大型数组的迭代，for range真的比经典for loop慢吗？

欢迎使用邮件订阅我的博客

文章

评论

分类

归档

链接

开源项目

翻译项目

标签 数组 下的文章

评点2021-2022年上市的那些Go语言新书

1. 《Go语言底层原理剖析》 2021.8

2. 《Go语言设计与实现》 2021.11

3. 《Go语言精进之路》 2021.12.17

4. 《Go语言定制指南》 2022.2.1

5. 引进版新书简评

6. 小结

针对大型数组的迭代，for range真的比经典for loop慢吗？

欢迎使用邮件订阅我的博客

文章

评论

分类

标签

归档

链接

开源项目

翻译项目

标签数组下的文章