编程语言研究书库
Go 语言学习(第 2 版)

为什么有 Go,以及怎么把它装起来

为什么有 Go,以及怎么把它装起来

这一章讲两件事: 第一,Go 为什么存在——它诞生的那个年代,软件开发被哪些痛处折磨, 于是 Go 做了哪些与众不同的选择;第二,怎么把 Go 装进自己的电脑、跑出第一个程序。 读完你会拿到一张「Go 的设计取舍清单」,后面十八章里每一处语法, 几乎都能挂回这张清单上的某一条。

1. 顶层全景:一门被「太复杂」逼出来的语言

先把整条线摆出来:

  2009 年以前的软件开发痛点          Go 的回应(本章展开)
  ──────────────────────────────     ──────────────────────────────
  C++/Java 编译慢、依赖重       →    编译极快,标准库自带 HTTP/JSON
  多核 CPU 已经普及,但语言     →    goroutine + channel,把并发写进语言
  写并发又难又容易错                本身,而不是甩给操作系统的线程
  内存要自己申请和释放,          →    自带垃圾回收,内存由运行时看管
  释放错了就崩                      程序员不再手动还内存
  面向对象的继承体系越搭越肿     →    没有继承:用组合搭结构,用接口定能力
  异常机制让错误处理隐晦         →    错误就是普通的返回值,摆在明面上

图说:左边是病,右边是药。全书后面所有章节,讲的都是右边某味药的具体用法。

这一章先认识这些「药」的名字和来历,暂时不需要记住任何语法。

2. 它生在那个「复杂就是最大的病」的年代

书里对 Go 出生背景的判断只有一句,但分量很重: 在 Go 立项的时候,软件开发的头号问题是「复杂」—— 当时主流的开发语言是 C++ 和 Java,随之而来的是一堆具体的痛处: 安全漏洞多、内存占用高、跑得慢、调试困难1。

展开说这三个痛处,每一个后面都会变成 Go 的一项设计:

编译慢。 C++ 项目一大,编译一次喝几杯咖啡是常态。 大型程序由成千上万个文件组成,一个文件改了,编译器常常要把一大片重新算一遍。 Go 从第一天就把「编译快」当成硬指标——它的编译器做了一批刻意的简化 (比如没有头文件,依赖关系直白),目标是「大项目的编译时间以秒计」。 今天你在 Go 里习惯的那些「少即是多」的语法,很多其实是为编译速度付的学费换回来的。

并发难。 2000 年代中后期,CPU 厂商撞上了物理墙:单个核心的频率提不动了, 转而往一块芯片里塞越来越多的核心。可是 C++ 和 Java 那个年代的主流并发写法 (操作系统线程 + 锁)又重又容易错,普通程序员写不对。 语言如果不提供顺手的并发写法,多核硬件就等于白买——这是 Go 最想解决的问题, 也是第 15、16 两章的主角。

内存要自己还。 C++ 里你申请的每块内存都得自己还;忘了还,内存越攒越多 (这叫内存泄漏,程序慢慢吃掉所有内存直到被系统杀掉);还错了,程序当场崩。 书里把话说得很直白:死掉的、没人再用的对象就不该还占着地方1。 Go 的回应是让运行时替你还——这就是下面要讲的垃圾回收。

3. 2009 年的三个名字和一家公司

Go 由 Google 支持,创造者是三个在编程语言史上都留过名字的人: 罗伯特·格瑞史莫(Robert Griesemer)、罗布·派克(Rob Pike)、肯·汤普森(Ken Thompson) ——汤普森是 Unix 操作系统的原创者之一2。

2009 年 11 月 10 日公开发布,并且从一开始就开源 (源码公开、谁都可以看、可以免费用)2。

书里点了一件值得琢磨的事:Go 的创造者和社区造了很多原生由语言核心支持的工具, 一般不需要第三方库。比如 Go 自带对 HTTP、JSON、HTML 模板的支持—— 意思是「让一台机器响应网络请求」「把一个对象转成 JSON 文本」这类别人家要靠 额外装库才能干的事,Go 开箱就有2。这解释了 Go 后来为什么特别适合写网络服务: 基础设施不是外挂的,是长语言身上的。

这本书是 2025 年的第二版,但写作时引用的「最新版本」是 Go 1.20 (2023 年 2 月发布)3——版本信息已经落后,读的时候按机制读,别按版本号读。

4. Go 的特性清单:逐条讲透

书里给了一张特性清单4,我们按「解决什么问题 → 怎么做 → 代价」的口径逐条过。 清单较长,先用一张表总览,再挑承重的几条展开:

特性一句话作用它治什么病
垃圾回收运行时自动找回不再用的内存C++ 手动还内存,忘了还泄漏、还错了崩
并发支持(goroutine + channel)一个程序里同时跑多件事,并且让它们能安全对话多核时代,线程太难写
多核调度(GOMAXPROCS)决定同时用几个 CPU 核心并发写出来,还得吃满硬件
静态类型 + 编译型编译时定死每个变量的类型,直接编译成机器码类型错在跑之前就被抓住;不用虚拟机、跑得快
泛型(1.18 起)一段代码对多种类型通用没泛型时只能靠接口硬凑,别扭
测试支持自带 testing 包和 go test 命令测试不用另装框架
标准库OS、HTTP、JSON、XML 等开箱即用依赖地狱
跨平台Linux、Mac、Windows、FreeBSD 等都能跑一套代码处处编译
文档工具godoc 命令直接生成交互文档文档与代码分家、容易过期

4.1 垃圾回收:谁替你还不忘

垃圾回收的意思是:程序运行过程中,由语言自带的「清洁工」定期检查哪些内存块 已经没有任何人在用了,自动收走。 你不用写「释放」这个动作。

书里给的两个关键信息是4:

  • 目前 Go 用的是标记-清扫(mark-and-sweep,一种垃圾回收算法——算法就是解决一类问题的固定步骤): 先给还在被引用的对象打上标记, 再把没标记的当成垃圾清掉;
  • 这个清洁工是并发干活的——它和你的主程序同时跑,不会整个世界停下来等它扫地。

书里还补了一个对照:内存管理一般有两条路,一条是引用计数 (每块内存记一个「还有几个人在用我」,计数归零就释放——Swift 走这条路), 另一条就是垃圾回收(Go、Java、C# 走这条)5。 引用计数的好处是及时,坏处是解决不了「你引用我、我引用你、其实谁都用不着」 这种环形死结;垃圾回收能收拾这种局面,代价是要花算力定期扫描。

判断(我们的,不是书里的): 书里把垃圾回收描述成纯收益,但垃圾回收不是免费的—— 它会周期性打断程序、吃掉一部分 CPU。Go 这些年的版本更新, 很大一块内容就是在把清扫造成的停顿越压越短。 读这本书时记住:「不用手动还内存」是真的,「还内存不要钱」不是。 如果错,会错在: 如果你的程序是短命的命令行工具,垃圾回收的代价几乎不可见, 这时说它「不是免费」会显得夸大。

4.2 并发:goroutine 和 channel,一句话版本

并发就是一个程序里有多件事在同时推进——比如一个网络服务器同时应对一千个用户。 书里的定义很朴素:「同时运行多于一个任务,就叫并发」4。

Go 给并发造了两件专用的东西,名字先记住,第 15、16 章细讲:

  • goroutine(协程):可以粗略理解成「非常轻量的执行线程」。 你随手开一个函数让它自己跑,就能开成千上万个;
  • channel(通道):goroutine 之间传话用的管道,保证它们对话时不打架。

对照 Java:Java 的并发靠操作系统线程,书里评价为「贵,而且难懂」5。 goroutine 的轻正在于:它不是操作系统线程,而是 Go 运行时自己调度的, 所以能开到操作系统的几百上千倍那么多。

4.3 GOMAXPROCS:同时用几个核

GOMAXPROCS 是 Go 运行时的一个参数,决定同时最多用几个 CPU 核心来跑你的 goroutine。 默认值 = 这台机器能看到的 CPU 核心数4。 绝大多数时候你不用动它;遇到「并发开了却吃不满多核」的调优场景,才会想起它。

4.4 静态类型 + 编译型:两道保险和一种速度

两个词分开解释:

编译型:你的源代码不是由另一个程序一边看一边执行(那叫解释型,比如早期的 Python), 而是先由编译器整个翻译成机器码(处理器直接认识的指令), 之后操作系统自己就能跑这个文件,不需要任何「运行时引擎」站在中间4。

静态类型:每个变量在编译时就和一种类型绑死了,之后不能变。 这带来一个直接好处:如果你拿一个文本变量去做数学运算, 这个错误在编译那一秒就被抓住,而不是等程序跑到那一行才崩4。

这两件事合起来,就是 Go 程序「跑得比解释型语言快」的全部秘密,没有什么黑魔法。

4.5 泛型:1.18 才补上的那一课

泛型指的是:写一段代码(比如一个「排序」),这段代码不用关心它排的是整数还是文本, 编译器替你按具体类型各生成一份。 书里的解释是「一种可以和其他数据类型一起使用的类型」4。

书里明确交代了历史:泛型是 Go 1.18(2022 年 3 月)才引入的;在那之前, 想让一段代码同时管多种类型,得绕路用接口或 io.Reader,能行,但费劲4。

判断(我们的,不是书里的): 泛型晚到十三年这件事本身,就是 Go 设计哲学的标本—— Go 团队的原则是「没想清楚就不放进去」,哪怕整个社区催了十年。 想清楚之后(设计公开讨论了好几年)才落地。 如果错,会错在: 这种「晚而慎重」对语言是优点,对急用的人是缺点; 评价它好不好,取决于你站在哪一边。

4.6 剩下的几条,一次带过

  • 测试:Go 自带 testing 包和 go test 命令,还有函数级、内存级的基准测试(benchmark, 就是给函数计时、比快慢的那类工具)4。这一版的书到此为止,没讲怎么写测试;
  • 标准库:复用是编程的基本功,Go 的标准库直接提供 OS、运行时、HTTP、XML、JSON 这些包4;
  • 跨平台:Linux、Mac、FreeBSD、Windows、iOS、Android 都有 Go 的身影4;
  • 文档:godoc 命令把包里的注释生成交互文档,一个函数的说明和它的实现可以互跳4。

5. 「Go 算不算面向对象?」——书里的标准答案

这是你出门跟别的程序员聊天时一定会撞上的一题,值得整节讲。

先给结论,再给推理。Go 有面向对象的功能,但没有面向对象的形式。 书里的原话是:拿「面向对象语言」的标准定义往 Go 上套,套不上; 但它用另一套办法提供了同样的功能6。

对照着看:

别的面向对象语言有Go 用什么替代
类(class)结构体(struct):把若干字段捆在一起的一种类型,第 11 章细讲
继承(一个类 extends 另一个类)没有。结构之间用组合搭关系——把一个结构嵌进另一个结构
多态(同一句话对不同对象有不同效果)接口(interface):只规定「必须会干什么」,不限定「是什么」

书里特意用了 IS-A 和 Has-A 这两个行话,并给了 Go 的对应: 组合建立的是 IS-A 关系(嵌进去的结构,对外「是一种」外层结构), 接口建立的是 Has-A 关系(实现了接口就「拥有」这项能力)6。

另外两个经常一起被问到的「没有」:

  • 没有重载(overloading):C++/Java 里可以定义好几个同名函数、靠参数类型区分; Go 不允许。函数只认名字,名字一样就是同一个函数5。 书里给的解释很符合 Go 的脾气:按名字认函数,复杂度就没了;
  • 没有异常(try-catch):C++/Java 里出错就「抛异常」,调用栈一层层弹上去找 catch。 Go 没有这套。它的做法是:函数把错误当成普通返回值,放在最后一个返回位置传回来; 调用方拿到后拿它和 nil(Go 的空值,读作「无」)比一下——是 nil 就没出错, 不是 nil 就处理错误5。

最后这条是 Go 最著名的脾气,全书第 17 章专讲。先记住这个形状: 错误在 Go 里不是意外,是函数签名的一部分,摆在明面上。

6. 优点说完了,书里自己也承认的两个短板

这一节是书里「Pain points(痛处)」一节7,作者没有只夸,这很少见,值得原样接住:

短板一:在科学计算、人工智能这些领域,库还不够多。 Go 的标准库和第三方库在服务器、工具、云这方面很全, 但比起 Java 和 Python 在科学计算、AI 方向的积累,「还有很长的路要走」7。 这个判断到今天基本仍然成立:今天做 AI 模型训练,默认语言仍是 Python。

短板二:错误处理写起来啰嗦。 没有编译器替你兜着错误,全看程序员在每个函数返回后老老实实检查7。 写过 Go 的人都认得这种体验:同样的 if err != nil 两三行,一遍一遍写。 这是「错误摆在明面上」这条优点的账单——明面是有代价的。

判断(我们的,不是书里的): 这两个短板其实是同一个设计哲学的两面。 Go 把「简单」定义为「做一件事只有一条明路」,于是该啰嗦的地方就得啰嗦。 挑剔它啰嗦的人,和喜欢它透明的人,说的是同一条特性。 如果错,会错在: Go 1.18 之后泛型落地、err 处理也不断有新提案 (比如 check 关键字曾被反复讨论)——如果这类提案某天进了语言, 「啰嗦」这条短板会被部分修补,我们的判断就要修订。

7. 谁在用 Go:五个具名的应用

书里列了一批用 Go 开发的真实软件8,这张表值得记住, 因为它是「Go 适合干什么」最硬的证据:

软件它是干什么的为什么这件事指向 Go
Docker把应用连同它的运行环境一起打包成「容器」分发系统级操作 + 并发,正是 Go 的主场
Kubernetes管一大堆容器该跑在哪台机器上(Google 2014 年设计)大规模分布式控制,Go 的看家场景
OpenShiftRed Hat 的容器云平台同上的商业发行版
Dropbox网盘;从 Python 迁到 Go书里给的原因是:更好的并发、更快的执行8
InfluxDB开源的「时间序列」数据库(专存按时间一条一条来的数据)高并发写入 + 系统服务

注意这张表的整体形状:全是基础设施(容器、编排、网盘后端、数据库), 没有一个是用户直接摸到的界面程序。这就是 Go 的生态位:它在「机器和机器说话」 的那一层,不在「人和机器说话」的那一层。

8. 主线例子:从下载安装到跑出 hello, world

前面全是「为什么」,这一节把「怎么做」走一遍。这条主线贯穿本章后半: 一台 Windows 电脑,从什么都没有,到跑出一个 Go 程序。 每步旁边是具体动作和会看到的画面(依据原书第 2 章的安装流程9)。

第 ① 步:确认机器合不合要求

Go 官方支持 Linux、Mac、FreeBSD、Windows,32 位和 64 位的 x86 处理器; 如果你的系统不在名单里,还有 gccgo 这条后路10。 写一个简单的 Go 程序,你只需要两样东西:一个文本编辑器 + 一个 Go 编译器。

第 ② 步:下载

打开 go.dev 的下载页,按系统选安装包——Windows 选 .msi 安装程序。 装的时候一路 Next,安装程序会帮你做两件关键的事: 接受许可、把 Go 装进 C:\Program Files\Go\(想换位置可以点 Change 改)9。

第 ③ 步:装完先看版本号

安装程序已经把 Go 的 bin 目录加进了系统的环境变量(就是操作系统记的一张 「命令清单」,清单里的程序才能直接在终端里敲名字运行)。 所以打开终端,敲:

  go version

会回一行类似 go version go1.20 windows/amd64 的话——看到版本号,装好了。 如果终端说「不认识的命令」,十有八九是 bin 路径没进环境变量,回去补上再重开终端9。

第 ④ 步:写第一个程序

书里给的完整程序是这样的(保存成 hello.go):

package main

import "fmt"

func main() {
    fmt.Printf("hello, world\n")
}

先混个眼熟,不用读懂——第 3 章逐行拆。现在只记住三件事: 文件以 .go 结尾;func main 是入口,程序从这里开始跑; fmt 是管打印的包,Printf 是它的打印函数11。

第 ⑤ 步:跑起来

终端里进到文件所在目录,敲:

  go run hello.go

屏幕上出现 hello, world——第一个 Go 程序跑通了12。

第 ⑥ 步:以后想卸了 / 升级

卸载简单得出奇:直接把 Go 那个目录删掉—— Linux/macOS 是 /usr/local/go,Windows 是 C:\Program Files\Go\13。 升级就是装新版,直接覆盖旧的;覆盖出了问题,删了重装即可9。

9. 作者的判断与证据(哪些话是书里的,哪些没有)

这一章大部分是事实陈述(谁发明的、哪年发布、支持哪些平台), 证据在脚注里。值得单独点出来的是两类判断句:

书里的判断性质
「Go 出现前,软件开发的头号问题是复杂」作者的历史叙述,一种解读,不是可证的事实
「Go 的并发方式比 Java 线程简单」业界普遍共识,书里没有给量化证据
「Go 在科学计算/AI 方向库不够多」作者自己列的短板,至今基本成立
「错误处理依赖程序员自觉」语言机制的事实推论,可验证

书里有一处理论错误值得指出:讲面向对象那节说组合建立 IS-A、接口建立 Has-A6, 这个对应关系与软件工程里的通行用法恰好拧了——通行说法是组合是 Has-A (「有一个」),继承才是 IS-A(「是一个」)。原书此处可能笔误。读的时候以机制为准: Go 用组合搭结构、用接口定能力,这两点本身是对的。

10. 边界与局限

  • 版本信息停在 Go 1.20(2023 年 2 月)3。今天的 Go 已更新好几轮, 装的时候直接去官网拿最新版即可,机制不受影响;
  • 编辑器名单已经过时:书里推荐的 Atom 编辑器已于 2022 年底停止开发, Cloud9 云服务也已关停(补充,不在书里,来自通用知识)。 2025 年写书还推荐这些,说明这部分是沿用旧版素材;
  • 编辑器/IDE 清单(GoLand、VS Code、Vim 等)只是罗列,没有对比和推荐, 选哪个不会被书左右;
  • 「安装」一节大量篇幅是安装向导的截图说明,真正要紧的只有三步: 装、验证 go version、跑通 hello world。

11. 可带走的

  1. Go 生于「复杂是头号大敌」的判断:编译慢、并发难、内存手动管理, 三个病对应编译快、goroutine/channel、垃圾回收三味药;
  2. Go 没有类、没有继承、没有重载、没有异常——用 struct、组合、接口、 「错误当返回值」替代;和别的程序员聊 Go,先对齐这张表;
  3. 错误处理是签名的一部分:函数把 error 放在最后一个返回值, 调用方拿它和 nil 比(第 17 章展开);
  4. 垃圾回收是并发的标记-清扫,和主程序同时跑,但代价是它要花算力;
  5. 泛型 2022 年的 1.18 才来,且本书没讲泛型语法——想学泛型要另找材料;
  6. GOMAXPROCS 管 goroutine 同时用几个核,默认等于核心数;
  7. 装 Go 只有三件要紧事:装、终端里 go version 看到版本号、 go run hello.go 跑通;卸载就是删目录;
  8. Go 的主战场是基础设施:Docker、Kubernetes、Dropbox 后端、InfluxDB—— 「机器和机器说话」的那一层;
  9. 书里自认的两块短板:科学计算/AI 库不够多、错误处理啰嗦;
  10. 版本号按机制读:书的「最新版 1.20」已过时,机制没过时。

12. 原文地图

主题原书章原文位置
复杂是立项时的头号问题Introduction to Gotext/08-fm-learning-go-programming.txt:55(搜「complexity was the major concern」)
三创始人、2009-11-10 发布、自带 HTTP/JSONIntroduction to Gotext/08-fm-learning-go-programming.txt:64(搜「November 10, 2009」)
垃圾回收(标记-清扫、并发)Introduction to Gotext/08-fm-learning-go-programming.txt:77(搜「mark-and-sweep」)
GOMAXPROCS 默认值=核心数Introduction to Gotext/08-fm-learning-go-programming.txt:86(搜「GOMAXPROCS」)
泛型 1.18 引入Introduction to Gotext/08-fm-learning-go-programming.txt:95(搜「generics in the 1.18」)
组合 IS-A / 接口 Has-AIntroduction to Gotext/08-fm-learning-go-programming.txt:113(搜「IS-A relationship」)
引用计数 vs 垃圾回收Introduction to Gotext/08-fm-learning-go-programming.txt:143(搜「reference counting」)
无 try-catch、错误放最后返回值Introduction to Gotext/08-fm-learning-go-programming.txt:137(搜「try-catch-finally」)
没有重载Introduction to Gotext/08-fm-learning-go-programming.txt:134(搜「does not have a concept of method」)
短板:AI 方向、错误处理Introduction to Gotext/08-fm-learning-go-programming.txt:152(搜「demanding domain support」) · text/08-fm-learning-go-programming.txt:155(搜「Tedious error handling」)
Docker/Kubernetes/Dropbox 等应用Introduction to Gotext/08-fm-learning-go-programming.txt:173(搜「Kubernetes」) · text/08-fm-learning-go-programming.txt:176(搜「Dropbox migrated」)
支持平台与 gccgoEnvironment Setuptext/09-fm-learning-go-programming.txt:43(搜「gccgo」)
Go 1.20 是当时的最新版Environment Setuptext/09-fm-learning-go-programming.txt:46(搜「Go1.20 is the latest」)
Gc / Gccgo / GopherJS 三个编译器Environment Setuptext/09-fm-learning-go-programming.txt:115(搜「recursive descent parser」) · text/09-fm-learning-go-programming.txt:118(搜「GopherJS」)
安装后 go version 验证Environment Setuptext/09-fm-learning-go-programming.txt:203(搜「go version command」)
第一个程序、go runEnvironment Setuptext/09-fm-learning-go-programming.txt:216(搜「package main」) · text/09-fm-learning-go-programming.txt:249(搜「go run」)
卸载=删目录Environment Setuptext/09-fm-learning-go-programming.txt:265(搜「Delete the Go directory」)

Footnotes

  1. 出处:「Introduction to Go」第 55 段(text/08-fm-learning-go-programming.txt:55,搜「complexity was the major concern」)。原文:Go 立项时「complexity was the major concern」,C++/Java 时代的挑战包括安全漏洞、高内存占用、性能慢、调试难;「死对象不应存在,以免阻塞资源」。 ↩ ↩2

  2. 出处:「Introduction to Go」第 64 段(text/08-fm-learning-go-programming.txt:64,搜「November 10, 2009」)。原文:Go 由 Google 支持、Robert Griesemer / Rob Pike / Ken Thompson 创造,2009 年 11 月 10 日公开发布、开源;自带 HTTP、JSON、HTML 模板支持。 ↩ ↩2 ↩3

  3. 出处:「Environment Setup」第 46 段(text/09-fm-learning-go-programming.txt:46,搜「Go1.20 is the latest」)。原文:「Go1.20 is the latest version of Go and was released in February 2023」。 ↩ ↩2

  4. 出处:「Introduction to Go」第 71–107 段(text/08-fm-learning-go-programming.txt:77,搜「mark-and-sweep」;text/08-fm-learning-go-programming.txt:86,搜「GOMAXPROCS」;text/08-fm-learning-go-programming.txt:95,搜「generics」;text/08-fm-learning-go-programming.txt:101,搜「Standard library」)。特性清单的逐条原文散见该节各段。 ↩ ↩2 ↩3 ↩4 ↩5 ↩6 ↩7 ↩8 ↩9 ↩10 ↩11 ↩12

  5. 出处:「Introduction to Go」第 143 段(text/08-fm-learning-go-programming.txt:143,搜「reference counting」)与第 122–137 段(text/08-fm-learning-go-programming.txt:137,搜「try-catch-finally」)。引用计数与垃圾回收的对照、无重载、无异常的说明均在「Analogy with other languages」一节。 ↩ ↩2 ↩3 ↩4

  6. 出处:「Introduction to Go」第 113 段(text/08-fm-learning-go-programming.txt:113,搜「IS-A relationship」)。原文:Go 无继承,组合建立 IS-A 关系、接口建立 Has-A 关系——注意这与通行用法相反(通行是组合 Has-A、继承 IS-A),疑为原书笔误,正文已按机制更正。 ↩ ↩2 ↩3

  7. 出处:「Introduction to Go」第 152 与 155 段(text/08-fm-learning-go-programming.txt:152,搜「demanding domain support」;text/08-fm-learning-go-programming.txt:155,搜「Tedious error handling」)。 ↩ ↩2 ↩3

  8. 出处:「Introduction to Go」第 165–179 段(text/08-fm-learning-go-programming.txt:173,搜「Kubernetes」;text/08-fm-learning-go-programming.txt:176,搜「Dropbox migrated」)。Dropbox 为扩展系统「从 Python 迁移到 Go」。 ↩ ↩2

  9. 出处:「Environment Setup」第 127–271 段(text/09-fm-learning-go-programming.txt:203,搜「go version command」;text/09-fm-learning-go-programming.txt:271,搜「environment variables」)。Windows 安装十步、常见报错「go 命令不识别」要查环境变量,均出自该章。 ↩ ↩2 ↩3 ↩4

  10. 出处:「Environment Setup」第 43 段(text/09-fm-learning-go-programming.txt:43,搜「gccgo」)。原文:其他操作系统可用 gccgo。 ↩

  11. 出处:「Environment Setup」第 216–228 段(text/09-fm-learning-go-programming.txt:216,搜「package main」)。原书注明该程序的逐行解释在下一章。 ↩

  12. 出处:「Environment Setup」第 249 段(text/09-fm-learning-go-programming.txt:249,搜「go run file_name.go」)。 ↩

  13. 出处:「Environment Setup」第 265 段(text/09-fm-learning-go-programming.txt:265,搜「Delete the Go directory」)。 ↩

Learning Go Programming(第二版)— 全书拆解

Previous Page

第一个 Go 程序:解剖到每一行

Next Page

On this page

为什么有 Go,以及怎么把它装起来1. 顶层全景:一门被「太复杂」逼出来的语言2. 它生在那个「复杂就是最大的病」的年代3. 2009 年的三个名字和一家公司4. Go 的特性清单:逐条讲透4.1 垃圾回收:谁替你还不忘4.2 并发:goroutine 和 channel,一句话版本4.3 GOMAXPROCS:同时用几个核4.4 静态类型 + 编译型:两道保险和一种速度4.5 泛型:1.18 才补上的那一课4.6 剩下的几条,一次带过5. 「Go 算不算面向对象?」——书里的标准答案6. 优点说完了,书里自己也承认的两个短板7. 谁在用 Go:五个具名的应用8. 主线例子:从下载安装到跑出 hello, world第 ① 步:确认机器合不合要求第 ② 步:下载第 ③ 步:装完先看版本号第 ④ 步:写第一个程序第 ⑤ 步:跑起来第 ⑥ 步:以后想卸了 / 升级9. 作者的判断与证据(哪些话是书里的,哪些没有)10. 边界与局限11. 可带走的12. 原文地图Footnotes