标签 Cgo 下的文章

GoCN社区Go读书会第二期:《Go语言精进之路》

本文永久链接 – https://tonybai.com/2022/07/07/gocn-community-go-book-club-issue2-go-programming-from-beginner-to-master

本文是2022年6月26日我在GoCN社区的Go读书会第二期《Go语言精进之路》直播的文字稿。本文对直播的内容做了重新整理与修订,供喜欢阅读文字的朋友们在收看直播后的揣摩和参考。视频控的童鞋可以关注GoCN公众号和视频号看剪辑后的视频,也可以在B站GopherChina专区下收看视频回放(https://www.bilibili.com/video/BV1p94y1R7jg)。


大家晚上好,我叫白明,是《Go语言精进之路》一书的作者,也是tonybai.com的博主,很荣幸今天参加GoCN社区Go读书会第二期,分享一下我个人在写书和读书方面的经验和体会。

今天的分享包括三方面内容:

  • 写书的历程。一些Gopher可能比较好奇,这么厚的一套书是怎么写出来的,今天就和大家聊一聊。
  • 《Go语言精进之路》导读。主要是把这本书的整体构思与大家聊聊,希望通过这个导读帮助读者更好地阅读和理解这套书。
  • 我个人的读书方法与经验的简要分享。

首先和大家分享一下写书的历程。

一. 写书的历程

1. 程序员的“小目标”与写书三要素

今天收看直播的童鞋都是有追求的技术人员,可能心底都有写一本属于自己的书的小目标。这样可以把自己学习到的知识、技能和经验以比较系统的方式输出给其他人,可以帮助其他人快速学习和掌握本领域的知识、技能和经验。

当然写书还有其他好处,比如:提升名气、更容易混技术圈子、可能给你带来更好的职业发展机会,当然也会给你带来一些额外的副业收入,至于多少,还要看书籍的口碑与销量。

那怎么才能写书呢?作为“过来人”,我总结了三个要素,也是三个条件。

第一个要素是能力

这个很容易理解。以Go为例,如果你没有在Go语言方面的知识、技能的沉淀,没有对Go语言方方面面的较为深入的理解,你很难写出一本口碑很好的书籍。尤其是那种有原创性、独到见解的著书。而不是对前人资料做系统整理摘抄的编书。编书更常见于教材、字典等。显然著书对作者水平的要求更高。

第二个要素是意愿

写过书的同学都有体会,写书是一件辛苦活。需要你在正式工作之余付出大量业余时间伏案创作。并且对于小众技术类书籍来说,写书能带来的金钱上的收益和你付出的时长和精力不成正比。就这个问题,我曾与机械工业出版社的营销编辑老师聊过,得到的信息是:Go技术书籍的市场与Java、Python还没法比,即便是像Go语言圣经《Go程序设计语言》的销量也没法与Java、Python的头部书籍销量相比。

第三个要素是机会

记得小时候十分羡慕那些能出书的人,觉得都是大神级的人物。不过那个时候出书的确很难,机会应该很少,你要不是在学术圈里混很难出书。如今就容易地多了,渠道也多了。每年出版社都有自己的出版计划,各个出版社的编辑老师也在根据计划在各种自媒体上、技术圈子中寻觅匹配的技术作者。

如果你有自己的思路,也可以整理出大纲,并通过某种方式联系到出版社老师,如果匹配就可以出。

另外国外流行电子自助出版,这也给很多技术作者很好的出版机会。比如国内作者老貘写的Go 101系列就是在亚马逊leanpub上做的自助出版,效果还不错。

以上就是我总结的出书的三个要素,一旦集齐这三个要素呢,出书实际就是自然而然的一件事了。以我为例。

从能力方面来说呢,我大约从2011年开始接触和学习Go语言,算是国内较早的一批Go语言接纳者。Go语言2012年才发布1.0版本,因此那时我接触的Go时还是r60版本,还不是正式的1.0版本。从那时起就一直在跟踪Go演化,日常写一些Go项目的小程序。

Go 1.5实现自举并大幅降低GC延迟,我于是开始在一些生产环境使用Go,并逐渐将知识和经验做了沉淀,在自己的博客上不断做着Go相关内容的输出,反响也不错。

随着输出Go内容的增多,我发现以博客的形式输出,内容组织零散,于是我第一次有了将自己的Go知识系统整理并输出的意愿和想法。

我在实践Go的过程中收到很多Go初学者的提问:Go入门容易,但精进难,怎么才能像Go开发团队那样写出符合Go思维和语言惯例的高质量代码呢?这个问题引发了我的思考。在2017年GopherChina大会我以《go coding in go way》为主题,以演讲的形式尝试回答这个问题,但鉴于演讲的时长有限,很多内容没能展开,效果不甚理想。这进一步增强了我通过书籍的形式系统解答这个问题的意愿。

而当时我家大宝已经长大了,我也希望通过写书这个行动身体力行地给孩子树立一个正面的榜样。中国古语有云:言传身教,我也想践行一下。

机会就这样自然而然的来了!2018年初,机械工业出版社副总编杨福川老师在微信联系到我,和我探讨一下是否可以写一本类似于“Effective Go”的书,当时机械工业出版社华章出版社策划了Effective XXX(编写高质量XXX)系列图书,当时已经出版了C、Python等语言版本的书籍,还差Go语言的。我的出书意愿与出版社的需求甚是匹配,于是我答应的杨老师的要求,成为了这套丛书的Go版本的作者。

2. 写书的过程

我是2018下旬开始真正动笔的。

真正开始码字的时候,我才意识到,写书真不容易,要写出高质量书稿,的确需付出大量时间和汗水。每天晚上、早上都在构思、码字、写代码示例、画插图,睡眠时间很少。记得当时每周末都在奋笔疾书,陪伴家人尤其是孩子的时间很少。

另外我这个人还习惯于把一个知识点讲细讲透,这样每一节的篇幅都不小。因此,写作进展是很缓慢的,就这样,进度一再延期。好在编辑老师比较nice,考虑到书稿质量,没有狠狠催进度。

2020年11月末,我正式向出版社交了初稿,记得初稿有66条,近40w字。

又经过一年的排期、编辑、修订、排版,2021年12月下旬正式出版。

2022年1月《Go语言精进之路》正式上架到各个渠道货架。

到今天为止,出版了近六个月,这本书收获了还不错的口碑,在各个平台上的口碑都在8分以上(注:口碑分数还在动态变化,下图仅为当时的快照,不代表如今的分数)。


能获得大家的认可,让我很是欣慰,觉得写书过程付出的辛苦没有白费。

以上就是我的写书历程。总的来说一句话:写书不易,写高质量的书更难

接下来我来进行一下《Go语言精进之路》一书的导读。

二. 《Go语言精进之路》导读

也许是“用力过猛”,《Go语言精进之路》一书写的太厚了,无法装订为一册。编辑老师建议装订为两册,即1、2册。很多同学好奇为什么不是上下册而是1、2册,这里是编辑老师的“高瞻远瞩”,目的是为后续可能的“续写”(比如第3册)留足空间,毕竟Go语言还在快速演进,目前的版本还不包含像泛型这样的新语法。不过,目前第3册还尚未列入计划。

本套书共分为10个部分,66个主题。第一册包含了前7个部分,后3部分在第二册中。

1. 整体写作思路

整套书围绕着两个前后关联的思路循序展开。

第一个思路我叫它:精进之路,思维先行

第二个思路称为:践行哲学,遵循惯例,认清本质,理解原理

我们先来看看第一个思路。

2. 精进之路,思维先行

收看直播的童鞋都不止学过一门编程语言。大家可能都有过这样的经历:你已经精通A语言,然后在学习B语言的时候用A语言的思维去写B代码,你会觉得写出的B代码很别扭,写出的代码总是感觉不是很地道,总觉得不是那种高质量的B语言代码。

其实,不仅学习编程语言是这样,学自然语言也是一样。最典型的一个例子,大家都学过十几年的英语,但毕业后能用地道的英语表达自己观点的人却不多,为什么呢?那就是我们总用中文的思维方式去组织英语的句子,去说英语,这样再怎么努力也很难上一个层次。

其实,很多语言大师早就意识到了这一点。下面是我收集的这些大师的关于语言与思维的论点,这里和大家分享一下:

“语言决定思维方式” – 萨丕尔假说

“我的语言之局限,即我的世界之局限” – 路德维希·维特根斯坦,语言哲学的奠基人

“不能改变你思维方式的语言,不值得学习” – Alan Perlis(首届ACM图灵奖得主)

我们看到:无论是自然语言界的大师,还是IT界的大佬,他们的观点异曲同工。总之一句话:语言要精进,思维要先行

3. Part1:进入Go语言编程思维导引

正是因为意识到语言与思维的紧密关系,我在书的第一部分就安排了Go语言编程思维导引,希望大家意识到Go编程思维在语言精进之路上的重要性。

一门编程语言的思维也不是与生俱来的,而是在演进中逐步形成的。所以在这一部分,我安排了Go诞生与演进、Go设计哲学:简单、组合、并发、面向工程。这样做的目的是让大家一起了解Go语言设计者在设计Go语言时的所思所想,让读者站在语言设计者的高度理解Go语言与众不同的设计,认同Go语言的设计理念。因为这些是Go编程语言思维形成的“土壤”

这一部分最后一节是Go编程思维举例导引,书中给出了C, Haskell和Go程序员在面对同一个问题时,首先考虑到的思维方式以及不同思维下代码设计方式的差异。

知道Go编程思维的重要性后,我们应该怎么做呢?

4. 怎么学习Go编程思维?

学习的本质是一种模仿。要学习Go思维,就要去模仿Go团队、Go社区的优秀项目和代码,看看他们怎么做的。这套书后面的部分讲的就是这个。而“践行哲学,遵循惯例,认清本质,理解原理”就是对后面内容的写作思路的概要性总结。

  • 践行哲学

把Go设计哲学用于自己的项目的设计实践中,而不是仅停留在口头知道上。

  • 遵循惯例

遵循Go团队的一些语言惯例,比如“comma,ok”、使用复合字面值初始化等,使用这些惯例你可以让你的代码显得很地道,别人一看就懂。

  • 认清本质

为了更高效地利用语言机制,我们要认清一些语言机制背后的本质,比如切片、字符串在运行时的表示,这样一来既能帮助开发人员正确使用这些语法元素,同时也能避免入坑。

  • 理解原理

Go带有运行时。运行时全程参与Go应用生命周期,因此,只有对Goroutine调度、GC等原理做适当了解,才能更好的发挥Go的威力。

这套书的part2-part10 就是基于对Go团队、Go社区优秀实践与惯例的梳理,用系统化的思路构建出来并循序渐进呈现给大家的。

5. Part2 – 项目基础:布局、代码风格与命名

这部门的内容是每个gopher在开启一个Go项目时都要考虑的事情。

  • 项目布局

我见过很多Gopher问项目布局的事情,因为Go官方没有给出标准布局。本书讲解了Go项目的结构布局的演进历程以及Go社区的事实标准,希望能给大家提供足够的参考信息。

  • 代码风格

针对Go代码风格,由于代码风格在Go中已经弱化,所以这里主要还是带大家理解gofmt存在的意义和使用方法。

  • 命名惯例

关于命名,我不知道大家是否觉得命名难,但对我来说是挺难的,我总是绞尽脑汁在想用啥名(手动允悲)。所以我的原则是“代码未动,命名先行”。 对于Go中变量、标识符等的命名惯例这样的“关键的问题”,我使用了“笨方法”:我统计了Go标准库、Docker库、k8s库的命名情况,并分门别类给出不同语法元素的命名惯例,具体内容大家可以看书了解 。

6. Part3 – 语法基础:声明、类型、语句与控制结构

第三部分讲的很基础,但内容还是要高于基础的。

  • 一致的变量声明

我们知道Go提供多种变量声明方式,但是在不同位置该用哪种声明方式可读性好又不容易造坑呢(尤其要注意短变量声明)?书中给出了系统阐述。

  • 无类型常量与iota

大家都用过常量,但很多人对于无类型常量与有类型常量区别不了解,书中帮你做了总结。还有,很多人用过iota,但却不理解iota的真正含义以及它能帮你做啥。书中对iota的语义做了说明,对常见用途做了梳理。

  • 零值可用

Go提倡零值可用,也内置了有很多零值可用类型,用起来很爽,比如:切片(不全是,仅在append时是零值可用,当用下标访问时,不具备零值可用)、sync包中的Mutex、RDMutex等

其实类比于线程(thread),goroutine也是一种零值可用的“类型”,只是Go没有goroutine这个类型罢了。

如果我们是包的设计者,如果提供零值可用的类型,可以提升包的使用者的体验。

  • 复合字面值来初始化

使用复合字面值对相应的变量进行初始化是一个Go语言的惯例, Go虽然提供了new和make,但日常很少用,尤其是new。

  • 切片、字符串、map的原理、惯用法与坑

Go是带有runtime的语言,语法层面展示的很多语法元素和runtime层真实的表示并不一致。要想高效利用这些类型,如果不了解runtime层表示还真不行。有时候还有很严重的“坑”。懂了,自然就能绕过坑。

  • 包导入

Go源文件的import语句后面跟着的是包名还是包路径?Go编译是不是必须要有依赖项的源码才可以,只有.a是否可以?这些问题书中都有系统说明

  • 代码块与作用域

代码块与作用域是Go语言的基础概念,虽然基础,如果理解不好,也是有“坑”的,比如最常见的变量遮蔽等。一旦理解透了,还可以帮你解决意想不到的语法问题和执行语义错误问题。

  • 控制语句

Go倡导“一个问题只有一种解决方法”。Go针对每种控制语句仅提供一种语法形式。虽然仅有一种形式,用不好,一样容器掉坑。本套书总结了Go控制语句的惯用法与使用注意事项。

7. Part4 – 语法基础:函数与方法

我们日常编写的Go代码逻辑都在函数或方法中,函数/方法是Go程序逻辑的基本承载单元。

  • init函数

init函数是包初始化过程中执行的函数,它有很多特殊用途。并且其初始化顺序对程序执行语义也有影响,这方面要搞清楚。书中对init函数的常见用途做了梳理,比如database/sql包的驱动自注册模式等。

  • 成为“一等公民”

在Go中,函数成为了“一等公民”。函数成为一等公民后可以像变量一样,被作为参数传递到函数中、作为返回值从函数中返回、作为右值赋值给其他变量等,书中系统讲解了这个特性都有哪些性质和特殊应用,比如函数式编程等。

  • defer语句的惯用法与坑

defer就是帮你简化代码逻辑的,书中总结了defer语句的应用模式。以及使用defer的注意事项,比如函数求值时机、使用开销等。

  • 变长参数函数

Go支持变长参数函数。大家可以没有意识到:变长参数函数是我们日常用的最多的一类函数,比如append函数、fmt.Printf系列、log包中提供的按日志严重级别输出日志的函数等。

但变长参数函数可能也是我们自己设计与实现较少的一类函数形式。 变长参数函数能帮我们做什么呢?书中讲解了变长参数函数的常见用途,比如实现功能选项模式等。

  • 方法的本质、receiver参数类型选择、方法集合

方法的本质其实是函数,弄清楚方法的本质可以帮助我们解决很多难题,书中以实例方式帮助大家理解这一点。

方法receiver参数类型的选择也是Go初学者的常见困惑,这里书中给出三个原则,参照这三个原则,receiver类型选择就不是问题了。

怎么确定一个类型是否实现接口?我们需要看类型的方法集合。那么确定一个类型方法集合就十分重要,尤其是那些包括类型嵌入的类型的方法集合,书中对这块内容做了系统的讲解。

8. Part5 – 语法核心:接口

  • 接口的内部表示

接口是Go语言中的重要语法。Russ Cox曾说过:“如果要从Go语言中挑选出一个特性放入其他语言,我会选择接口”。可见接口的重要性。不过,用好接口类型的前提是理解接口在runtime层的表示,这一节会详细说明空接口与非空接口的内部表示。

  • 接口的设计惯例

我们应该设计什么样的接口呢? 大接口有何弊端?小接口有何优势?多小的接口算是合理的呢?这些在本节都有说明。

  • 接口与组合

组合是Go的设计哲学,Go是关于组合的语言。接口在面向组合编程时将发挥重要作用。这里我将提到Go的两种组合方式:垂直组合和水平组合。其中接口类型在水平组合中起到的关键性的作用。书中还讲解了通过接口进行水平组合的几种模式:包裹模式、适配器函数、中间件等。

很多初学者告诉我,他们做了一段时间Go编码了,但还没有自己设计过接口,我建议这样的同学好好读读这一部分。

9. Part6 – 语法核心:并发编程

  • 并发设计vs并行设计

学习并发编程首先要搞懂并发与并行的概念,书中用了一个很形象的机场安检的例子,来告诉大家并发与并行的区别。并发关乎结构,并行关注执行

  • 并发原语的原理与应用模式

Go实现了csp模型,提供了goroutine、channel、select并发原语。

理解go并发编程。首先要深入理解基于goroutine的并发模型与调度方式。书中对这方面做了深入浅出的讲解,不涉及太多代码,相信大家都能看懂。

书中还对比了go并发模型,一种是csp,一种是传统的基于共享内存方式,并列举了Go并发的常见模式,比如创建、取消、超时、管道模式等。

另外,channel作为goroutine间通信的标准原语,有很多玩法,这里列举了常见的模式和使用注意事项。

  • 低级同步原语(sync和atomic)

虽然有了CSP模型的并发原语,极大简化并发编程,但是sync包和原子操作也不能忘记,很多性能敏感的临界区还需要sync包/atomic这样的低级同步原语来同步。

10. Part7 – 错误处理

单独将错误处理拎出来,是因为很多人尤其是来自java的童鞋,习惯了try-catch-finally的结构化错误处理,看到go的错误处理就让其头疼。

Go语言十分重视错误处理,但它也的确有着相对保守的设计和显式处理错误的惯例。

本部分涵盖常见Go错误处理的策略、避免if err != nil写太多的方案,更为重要的是panic与错误处理的差别。我见过太多将panic用作正常处理的同学了。尤其是来自java阵营的童鞋。

11. Part8 – 编程实践:测试、调试与性能剖析

本部分聚焦编码之外的Go工具链工程实践。

  • Go测试惯例与组织形式

这部分首先和大家聊聊go test包的组织形式,包括是选择包内测试还是包外测试?何时采用符合go惯例的表驱动的测试用例组织形式?如何管理测试依赖的外部数据文件等。

  • 模糊测试(fuzzing test)。

这里的模糊测试并非基于go 1.18的原生fuzzing test进行,写书的时候go 1.18版本尚未发布,而是基于德米特里-维尤科夫的go-fuzz工具

  • 性能基准测试、度量数据与pprof性能剖析

Go原生提供性能基准测试。这一节讲解了如何做性能基准测试、如何编写串行与并行的测试、性能基准测试结果比较工具以及如何排除额外干扰,让结果更准确等方面内容。在讲解pprof性能剖析工具时,我使用一个实例进行剖析讲解,这样理解起来更为直观。

  • Go调试

说到Go调试,我们日常使用最多的估计还是print大法。但在print大法之外,其实有一个事实标准的Go调试工具,它就是delve。在这一节中,我讲解了delve的工作原理以及使用delve如何实现并发调试、coredump调试以及在线挂接(attach)进程的调试。

12. Part9 – 标准库、反射与cgo

go是自带电池,开箱即用的语言,拥有高质量的标准库。在国外有些Gopher甚至倡导仅依赖标准库实现go应用。

  • 高频使用的标准库包(net、http、strings、time、crypto等)

在这一节,我对高频使用的标准库包的原理和使用进行拆解分析,net、http、标准库io模型、strings、time、crypto等以帮助大家更高效的运用标准库。

  • reflect包使用的三大法则

reflect包为go提供了反射能力,书中对反射的实现原理做了讲解,重点是reflect使用的三大法则。

  • cgo使用

cgo不是go,但是cgo机制是使用go与c交互的唯一手段。书中对cgo的用法与约束做了详细讲解,尤其是在cgo开启的情况下如何做静态编译值得大家细读。

  • unsafe包的安全使用法则

事实证明unsafe包很有用,但要做到安全使用unsafe包,尤其是unsafe.Pointer,需要遵循一定的安全使用法则。书中对此做了举例详细说明。

反射、cgo、unsafe算是高级话题,要透彻理解,需要多阅读几遍书中内容并结合实践。

13. Part10 – 工程实践

  • go module

go module在go 1.11版本中引入go,在go 1.16版本中成为go官方默认构建模式。go程序员入门go,精进go都跨不过go module这道坎儿。书中对go module构建模式做了超级系统的讲解:从go构建模式演进历史、go module的概念、原理、惯例、升降级major版本的操作,到使用注意事项等。不过这里还有有一些瑕疵,那就是go module这一节放置的位置太靠后了,应该往往前面提提。如果后面有修订版,可以考虑这么做。

  • 自定义go包导入路径

书中还给出了一个自定义go包导入路径的一种实现方案,十分适合组织内部的私有仓库,有兴趣的同学可以重点看看。

  • go命令的使用模式详解

这一节将go命令分门别类地进行详细说明。包括:

- 获取与安装的go get/go install
- go包检视的go list
- go包构建的go build
- 运行与诊断的GODEBUG、GOGC等环境变量的功用
- 代码静态检查与重构
- 文档查看
- go代码生成go generate
  • Go常见的“坑”

这一节将Go常见的“坑”进行了一次检阅。我这里将坑分为“语法类”和“标准库类”,并借鉴了央视五套天下足球top10节目,对每个坑的“遇坑指数”与“坑害指数”做了点评。

14. 具备完整的示例代码与勘误表

这套书拥有具备完整的示例代码与勘误表,它们都被持续维护,让大家没有读书的后顾之忧。

三. 读书的实践与体会

下面我再分享一下我个人是怎么读书的,包括go技术书籍的读书历程,以及关于读书的一些实践体会。

读书是千人千面的事,没有固定标准的。我的读书方法也不见得适合诸位。大家听听即可,觉得还不错,能借鉴上就最好了。

今天收看直播估计以gopher为主,所以首先说说Go语言书籍的阅读历程

1. Go语言书籍阅读历程:先外后内

对于IT技术类图书,初期还是要看原版的。这个没办法,因为it编程技术绝大多数来自国外。

我读的第一本Go技术书就是《the way to go》,至今这本书也没有引入国内。这是一本Go语言百科全书,大多数内容如今仍适用。唯一不足是该书成书于Go 1.0发布之前,使用的好像是r60版本,有少部分内容已经不适用。

后来Go 1.0发布后,我还陆续读过Addison-Wesley出版的《programming in go》和《The Go Programming Language Phrasebook》,两本书都还不错。

2015年末的布莱恩.克尼根和go核心团队的多诺万联合编写的《The Go Programming Language》,国内称之为Go圣经的书出版了,这让外文go技术书籍达到了巅峰,后来虽然也有go书籍书籍陆续出版,但都无法触及go圣经的地位。

说完外文图书,我再来说说中文Go图书的阅读历程。

我读过的第一本中文Go书籍是2012年许式伟老师的《Go语言编程》,很佩服许老师的眼光和魄力,七牛云很早就在生产用go。

第二本中文Go书籍是雨痕老师的《go学习笔记》,这也是国内第一本深入到go底层原理的书籍(后半部分),遗憾的是书籍停留在go 1.5(还是go 1.6)的实现上,没有随Go版本演进而持续更新。

柴大和曹大合著的《go高级编程》也是一本不错的go技术书籍,如果你要深入学习cgo和go汇编,建议阅读此书。

后面的《Go语言底层原理剖析》和《Go语言设计与实现》也都是以深入了解Go运行机制为目标的书籍,口碑都很好,对这方面内容感兴趣的gopher,可以任意挑一本学习。

2. 自己的读书方法

我的读书方法其实不复杂,主要分为精读和泛读。

  • 阅读方式:好书精读,闲书泛读

好书,集中一大段时间内进行阅读。 闲书(不烧脑),通常是 碎片化阅读。

  • 精读方法:摘录+脑图+行动清单

摘录就是将书中的观点和细节摘录出来,放到读书笔记,最好能用自己的语言重新描述出来,这样印象深刻,理解更为透彻。

脑图,概括书的思维脉络,防止读完就忘记。 通过脑图,我至少看着脉络能想起来。

行动清单:如果没有能输出行动清单,那这本书对你来说意义就不大。 什么是好书,好书就是那种看完后很迫切的想基于书中的观点做点什么。行动清单将有助于我在后续的行动中反复理解书中内容,提高知识的消化率和理解深度。

  • 泛读方法:碎片化+听书

泛读主要是碎片化快读或听书,主要是坐地铁,坐公交,散步时。开车时在保证安全的前提下,可以用听书的方式。

四. 小结

本次分享了三块内容,这里小结一下:

  • 写书历程和写书三要素:能力 + 意愿 + 机会;
  • Go精进之路导读:思维先行,践行哲学,遵循惯例,认清本质,理解原理;
  • 读书方法:选高质量图书精读(脑图+细节摘录+行动清单)。

五. Q&A

  • 在实际开发中有没有什么优雅的处理error的方法?

建议看《Go语言精进之路》第一册第七部分中关于error处理的内容。

  • 是否在工作中使用过六边形架构以及依赖注入的处理经验?

暂没有使用过六边形架构,生产中没有使用过Go第三方依赖注入的方案。

  • 后面会有泛型和模糊测试的补充么?

从书籍内容覆盖全面性的角度而言,我个人有补充上述内容的想法,但还要看现在这套书的销售情况以及出版社的计划。目前还没列入个人工作计划。

  • 作者总结一系列go方法论、惯例等很实用,这种有逻辑的思考和见解是怎么形成的?

没有特意考虑过是怎么形成的。个人平时喜欢多问自己几个为什么,形成让自己信服的工作和学习逻辑。(文字稿补充:同理心、多总结、多复盘、多输出)。

学习Go惯例、方法论,可以多多看Go语言开源项目自身的代码评审,看看Go contributor写代码的思路和如何评审其他贡献者的代码的。(文字稿补充:在这一过程中,潜移默化的感受Go编程思维)。

  • 如何阅读大型go项目的源码?

我个人的方法就是自上而下。先拆分结构,然后找入口。如果是一个可执行的go程序,还是从入口层层的向后看。然后通过一些工具,比如我个人之前开发的函数调用跟踪工具,查看程序执行过程中的函数调用次序。

更细节的内容,还是要深入到代码中去查看。

  • 对Go项目中的一些设计模式的看法?如何使用设计模式,使用时注意哪些事项?

设计模式在go语言中并不是一个经常拿出来提的东西。我之前的一个观点:在其他语言中,需要大家通过一些额外细心的设计构建出来的设计模式,在Go语言中是自然而然就有的东西。

我在自己的日常编码过程中,不会太多从如何应用设计模式的角度思考,而是按照go设计哲学,去考虑并发设计、组合的设计,而不是非要套用那23个经典设计模式。


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

img{512x368}
img{512x368}

img{512x368}
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

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

Go程序员拥抱C语言简明指南

本文永久链接 – https://tonybai.com/2022/05/16/the-short-guide-of-embracing-c-lang-for-gopher

本文是为于航老师的极客时间专栏《深入C语言和程序运行原理》写的加餐文章《Tony Bai:Go程序员拥抱C语言简明指南》,这里分享给大家,尤其是那些想学习C语言的Gopher们。


你好,我是Tony Bai。

也许有同学对我比较熟悉,看过我在极客时间上的专栏《Tony Bai ·Go语言第一课》,或者是关注了我的博客。那么,作为一个Gopher,我怎么跑到这个C语言专栏做分享了呢?其实,在学习Go语言并成为一名Go程序员之前,我也曾是一名地地道道的C语言程序员。

大学毕业后,我就开始从事C语言后端服务开发工作,在电信增值领域摸爬滚打了十多年。不信的话,你可以去翻翻我的博客,数一数我发的C语言相关文章是不是比关于Go的还多。一直到近几年,我才将工作中的主力语言从C切换到了Go。不过这并不是C语言的问题,主要原因是我转换赛道了。我目前在智能网联汽车领域从事面向云原生平台的先行研发,而在云原生方面,新生代的Go语言有着更好的生态。

不过作为资深C程序员,C语言已经在我身上打下了深深的烙印。虽然Go是我现在工作中的主力语言,但我仍然会每天阅读一些C开源项目的源码,每周还会写下数百行的C代码。在一些工作场景中,特别是在我参与先行研发一些车端中间件时,C语言有着资源占用小、性能高的优势,这一点是Go目前还无法匹敌的。

正因为我有着C程序员和Go程序员的双重身份,接到这个加餐邀请时,我就想到了一个很适合聊的话题——在 Gopher(泛指Go程序员)与C语言之间“牵线搭桥”。在这门课的评论区里,我看到一些同学说,“正是因为学了Go,所以我想学好C”。如果你也对Go比较熟悉,那么恭喜你,这篇加餐简直是为你量身定制的:一个熟悉Go的程序员在学习C时需要注意的问题,还有可能会遇到的坑,我都替你总结好了。

当然,我知道还有一些对Go了解不多的同学,看到这里也别急着退出去。因为C和Go这两门语言的比较,本身就是一个很有意思的话题。今天的加餐,会涉及这两门语言的异同点,通过对C与Go语言特性的比较,你就能更好地理解“C 语言为什么设计成现在这样”。

一. C语言是现代IT工业的根基

在比较C和Go之前,先说说我推荐Gopher学C的最重要原因吧:用一句话总结,C语言在IT工业中的根基地位,是Go和其他语言目前都无法动摇的

C语言是由美国贝尔实验室的丹尼斯·里奇(Dennis Ritchie)以Unix发明人肯·汤普森(Ken Thompson)设计的B语言为基础而创建的高级编程语言。诞生于上个世纪(精确来说是1972年)的它,到今年(2022年)已到了“知天命”的半百年纪。 年纪大、设计久远一直是“C语言过时论”兴起的根源,但如果你相信这一论断,那就大错特错了。下面,我来为你分析下个中缘由。

首先,我们说说C语言本身:C语言一直在演进,从未停下过脚步

虽然C语言之父丹尼斯·里奇不幸于2011年永远地离开了我们,但C语言早已成为ANSI(美国国家标准学会)标准以及ISO/IEC(国际标准化组织和国际电工委员会)标准,因此其演进也早已由标准委员会负责。我们来简单回顾一下C语言标准的演进过程:

  • 1989年,ANSI发布了首个C语言标准,被称为C89,又称ANSI C。次年,ISO和IEC把ANSI C89标准定为C语言的国际标准(ISO/IEC 9899:1990),又称C90,它也是C语言的第一个官方版本;
  • 1999年,ISO和IEC发布了C99标准(ISO/IEC 9899:1999),它是C语言的第二个官方版本;
  • 2011年,ISO和IEC发布了C11标准(ISO/IEC 9899:2011),它是C语言的第三个官方版本;
  • 2018年,ISO和IEC发布了C18标准(ISO/IEC 9899:2018),它是C语言的第四个官方版本。
    目前,ISO/IEC标准化委员会正在致力于C2x标准的改进与制定,预计它会在2023年发布。

其次,时至今日,C语言的流行度仍然非常高

著名编程语言排行榜TIOBE的数据显示,各大编程语言年度平均排名的总位次,C语言多年来高居第一,如下图(图片来自TIOBE)所示:

这说明,无论是在过去还是现在,C语言都是一门被广泛应用的工业级编程语言。

最后,也是最重要的一点是:C语言是现代IT工业的根基,我们说C永远不会退出IT行业舞台也不为过。

如今,无论是普通消费者端的Windows、macOS、Android、苹果iOS,还是服务器端的Linux、Unix等操作系统,亦或是各个工业嵌入式领域的操作系统,其内核实现语言都是C语言。互联网时代所使用的主流Web服务器,比如 Nginx、Apache,以及主流数据库,比如MySQL、Oracle、PostgreSQL等,也都是使用C语言开发的杰作。可以说,现代人类每天都在跟由C语言实现的系统亲密接触,并且已经离不开这些系统了。回到我们程序员的日常,Git、SVN等我们时刻在用的源码版本控制软件也都是由C语言实现的。

可以说,C语言在IT工业中的根基地位,不光Go语言替代不了,C++、Rust等系统编程语言也无法动摇,而且不仅短期如此,长期来看也是如此。

总之,C语言具有紧凑、高效、移植性好、对内存的精细控制等优秀特性,这使得我们在任何时候学习它都不会过时。不过,我在这里推荐Gopher去了解和系统学习C语言,其实还有另一个原因。我们继续往下看。

二. C与Go的相通之处:Gopher拥抱C语言的“先天优势”

众所周知,Go 是在C语言的基础上衍生而来的,二者之间有很多相通之处,因此 Gopher 在学习C语言时是有“先天优势”的。接下来,我们具体看看C和Go的相通之处有哪些。

1. 简单且语法同源

Go语言以简单著称,而作为Go先祖的C语言,入门门槛同样不高:Go有25个关键字,C有32个关键字(C89标准),简洁程度在伯仲之间。C语言曾长期作为高校计算机编程教育的首选编程语言,这与C的简单也不无关系。

和Go不同的是,C语言是一个小内核、大外延的编程语言,其简单主要体现在小内核上了。这个“小内核”包括C基本语法与其标准库,我们可以快速掌握它。但需要注意的是,与Go语言“开箱即用、内容丰富”的标准库不同,C标准库非常小(在C11标准之前甚至连thread库都不包含),所以掌握“小内核”后,在LeetCode平台上刷题是没有任何问题的,但要写出某一领域的工业级生产程序,我们还有很多外延知识技能要学习,比如并发原语、操作系统的系统调用,以及进程间通信等。

C语言的这种简单很容易获得Gopher们的认同感。当年Go语言之父们在设计Go语言时,也是主要借鉴了C语言的语法。当然,这与他们深厚的C语言背景不无关系:肯·汤普森(Ken Thompson)是Unix之父,与丹尼斯·里奇共同设计了C语言;罗博·派克(Rob Pike)是贝尔实验室的资深研究员,参与了Unix系统的演进、Plan9操作系统的开发,还是UTF-8编码的发明人;罗伯特·格瑞史莫(Robert Griesemer)也是用C语言手写Java虚拟机的大神级人物。

Go的第一版编译器就是由肯·汤普森(Ken Thompson)用C语言实现的。并且,Go语言的早期版本中,C代码的比例还不小。以Go语言发布的第一个版本,Go 1.0版本为例,我们通过loccount工具对其进行分析,会得到下面的结果:

$loccount .
all          SLOC=460992  (100.00%) LLOC=193045  in 2746 files
Go           SLOC=256321  (55.60%)  LLOC=109763  in 1983 files
C            SLOC=148001  (32.10%)  LLOC=73458   in 368 files
HTML         SLOC=25080   (5.44%)   LLOC=0       in 57 files
asm          SLOC=10109   (2.19%)   LLOC=0       in 133 files
... ...

这里我们看到,在1.0版本中,C语言代码行数占据了32.10%的份额,这一份额直至Go 1.5版本实现自举后,才下降为不到1%。

我当初对Go“一见钟情”,其中一个主要原因就是Go与C语言的语法同源。相对应地,相信这种同源的语法也会让Gopher们喜欢上C语言。

2. 静态编译且基础范式相同

除了语法同源,C语言与Go语言的另一个相同点是,它们都是静态编译型语言。这意味着它们都有如下的语法特性:

  • 变量与函数都要先声明后才能使用;
  • 所有分配的内存块都要有对应的类型信息,并且在确定其类型信息后才能操作;
  • 源码需要先编译链接后才能运行。

相似的编程逻辑与构建过程,让学习C语言的Gopher可以做到无缝衔接。

除此之外,Go 和C的基础编程范式都是命令式编程(imperative programming),即面向算法过程,由程序员通过编程告诉计算机应采取的动作。然后,计算机按程序指令执行一系列流程,生成特定的结果,就像菜谱指定了厨师做蛋糕时应遵循的一系列步骤一样。

从Go看 C,没有面向对象,没有函数式编程,没有泛型(Go 1.18已加入),满眼都是类型与函数,可以说是相当亲切了。

3. 错误处理机制如出一辙

对于后端编程语言来说,错误处理机制十分重要。如果两种语言的错误处理机制不同,那么这两种语言的代码整体语法风格很可能大不相同。

在C语言中,我们通常用一个类型为整型的函数返回值作为错误状态标识,函数调用者基于值比较的方式,对这一代表错误状态的返回值进行检视。通常,当这个返回值为0时,代表函数调用成功;当这个返回值为其他值时,代表函数调用出现错误。函数调用者需根据该返回值所代表的错误状态,来决定后续执行哪条错误处理路径上的代码。

C语言这种简单的基于错误值比较的错误处理机制,让每个开发人员必须显式地去关注和处理每个错误。经过显式错误处理的代码会更为健壮,也会让开发人员对这些代码更有信心。另外,这些错误就是普通的值,我们不需要额外的语言机制去处理它们,只需利用已有的语言机制,像处理其他普通类型值那样去处理错误就可以了。这让代码更容易调试,我们也更容易针对每个错误处理的决策分支进行测试覆盖。

C语言错误处理机制的这种简单与显式,跟Go语言的设计哲学十分契合,于是Go语言设计者决定继承这种错误处理机制。因此,当Gopher们来到C语言的世界时,无需对自己的错误处理思维做出很大的改变,就可以很容易地适应C语言的风格。

三. 知己知彼,来看看C与Go的差异

虽说 Gopher 学习C语言有“先天优势”,但是不经过脚踏实地的学习与实践就想掌握和精通C语言,也是不可能的。而且,C 和Go还是有很大差异的,Gopher 们只有清楚这些差异,做到“知己知彼”,才能在学习过程中分清轻重,有的放矢。俗话说,“磨刀不误砍柴功”,下面我们就一起看看C与Go有哪些不同。

1. 设计哲学

在人类自然语言学界,有一个很著名的假说——“萨丕尔-沃夫假说”。这个假说的内容是这样的:语言影响或决定人类的思维方式。对我来说,编程语言也不仅仅是一门工具,它还影响着程序员的思维方式。每次开始学习一门新的编程语言时,我都会先了解这门编程语言的设计哲学。

每种编程语言都有自己的设计哲学,即便这门语言的设计者没有将其显式地总结出来,它也真真切切地存在,并影响着这门语言的后续演进,以及这门语言程序员的思维方式。我在《Tony Bai · Go语言第一课》专栏里,将Go语言的设计哲学总结成了5点,分别是简单、显式、组合、并发和面向工程

那么C语言的设计哲学又是什么呢?从表面上看,简单紧凑、性能至上、极致资源、全面移植,这些都可以作为C的设计哲学,但我倾向于一种更有人文气息的说法:满足和相信程序员

在这样的设计哲学下,一方面,C语言提供了几乎所有可以帮助程序员表达自己意图的语法手段,比如宏、指针与指针运算、位操作、pragma指示符、goto语句,以及跳转能力更为强大的longjmp等;另一方面,C语言对程序员的行为并没有做特别严格的限定与约束,C程序员可以利用语言提供的这些语法手段,进行天马行空的发挥:访问硬件、利用指针访问内存中的任一字节、操控任意字节中的每个位(bit)等。总之,C语言假定程序员知道他们在做什么,并选择相信程序员。

C语言给了程序员足够的自由,可以说,在C语言世界,你几乎可以“为所欲为”。但这种哲学也是有代价的,那就是你可能会犯一些莫名其妙的错误,比如悬挂指针,而这些错误很少或不可能在其他语言中出现。

这里再用一个比喻来更为形象地表达下:从Go世界到C世界,就好比在动物园中饲养已久的动物被放归到野生自然保护区,有了更多自由,但周围也暗藏着很多未曾遇到过的危险。因此,学习C语言的Gopher们要有足够的心理准备。

2. 内存管理

接下来我们来看C与Go在内存管理方面的不同。我把这一点放在第二位,是因为这两种语言在内存管理上有很大的差异,而且这一差异会给程序员的日常编码带来巨大影响。

我们知道,Go是带有垃圾回收机制(俗称GC)的静态编程语言。使用Go编程时,内存申请与释放,在栈上还是在堆上分配,以及新内存块的清零等等,这一切都是自动的,且对程序员透明。

但在C语言中,上面说的这些都是程序员的责任。手工内存管理在带来灵活性的同时,也带来了极大的风险,其中最常见的就是内存泄露(memory leak)与悬挂指针(dangling pointer)问题。

内存泄露主要指的是程序员手工在堆上分配的内存在使用后没有被释放(free),进而导致的堆内存持续增加。而悬挂指针的意思是指针指向了非法的内存地址,未初始化的指针、指针所指对象已经被释放等,都是导致悬挂指针的主要原因。针对悬挂指针进行解引用(dereference)操作将会导致运行时错误,从而导致程序异常退出的严重后果。

Go语言带有GC,而C语言不带GC,这都是由各自语言设计哲学所决定的。GC是不符合C语言的设计哲学的,因为一旦有了GC,程序员就远离了机器,程序员直面机器的需求就无法得到满足了。并且,一旦有了GC,无论是在性能上还是在资源占用上,都不可能做到极致了。

在C中,手工管理内存到底是一种什么感觉呢?作为一名有着十多年C开发经验的资深C程序员,我只能告诉你:与内存斗,其乐无穷!这是在带GC的编程语言中无法体会到的。

3. 语法形式

虽然C语言是Go的先祖,并且Go也继承了很多C语言的语法元素,但在变量/函数声明、行尾分号、代码块是否用括号括起、标识符作用域,以及控制语句语义等方面,二者仍有较大差异。因此,对Go已经很熟悉的程序员在初学C时,受之前编码习惯的影响,往往会踩一些“坑”。基于此,我总结了Gopher学习C语言时需要特别注意的几点,接下来我们具体看看。

第一,注意声明变量时类型与变量名的顺序

前面说过,Go与C都是静态编译型语言,这就要求我们在使用任何变量之前,需要先声明这个变量。但Go采用的变量声明语法颇似Pascal语言,即变量名在前,变量类型在后,这与C语言恰好相反,如下所示:

Go:

var a, b int
var p, q *int

vs.

C:
int a, b;
int *p, *q;

此外,Go支持短变量声明,并且由于短变量声明更短小,无需显式提供变量类型,Go编译器会根据赋值操作符后面的初始化表达式的结果,自动为变量赋予适当类型。因此,它成为了Gopher们喜爱和重度使用的语法。但短声明在C中却不是合法的语法元素:

int main() {
    a := 5; //  error: expected expression
    printf("a = %d\n", a);
}

不过,和上面的变量类型与变量名声明的顺序问题一样,C编译器会发现并告知我们这个问题,并不会给程序带来实质性的伤害。

第二,注意函数声明无需关键字前缀

无论是C语言还是Go语言,函数都是基本功能逻辑单元,我们也可以说C程序就是一组函数的集合。实际上,我们日常的C代码编写大多集中在实现某个函数上。

和变量一样,函数在两种语言中都需要先声明才能使用。Go语言使用func关键字作为函数声明的前缀,并且函数返回值列表放在函数声明的最后。但在C语言中,函数声明无需任何关键字作为前缀,函数只支持单一返回值,并且返回值类型放在函数名的前面,如下所示:

Go:
func Add(a, b int) int {
    return a+b
}

vs.

C:
int Add(int a, int b) {
    return a+b;
}

第三,记得加上代码行结尾的分号

我们日常编写Go代码时,极少手写分号。这是因为,Go设计者当初为了简化代码编写,提高代码可读性,选择了由编译器在词法分析阶段自动在适当位置插入分号的技术路线。如果你是一个被Go编译器惯坏了的Gopher,来到C语言的世界后,一定不要忘记代码行尾的分号。比如上面例子中的C语言Add函数实现,在return语句后面记得要手动加上分号。

第四,补上“省略”的括号

同样是出于简化代码、增加可读性的考虑,Go设计者最初就取消掉了条件分支语句(if)、选择分支语句(switch)和循环控制语句(for)中条件表达式外围的小括号:

// Go代码
func f() int {
    return 5
}
func main() {
    a := 1
    if a == 1 { // 无需小括号包裹条件表达式
        fmt.Println(a)
    }

    switch b := f(); b { // 无需小括号包裹条件表达式
    case 4:
        fmt.Println("b = 4")
    case 5:
        fmt.Println("b = 5")
    default:
        fmt.Println("b = n/a")
    }

    for i := 1; i < 10; i++ { // 无需小括号包裹循环语句的循环表达式
        a += i
    }
    fmt.Println(a)
}

这一点恰恰与C语言“背道而驰”。因此,我们在使用C语言编写代码时,务必要想着补上这些括号:

// C代码
int f() {
        return 5;
}

int main() {
    int a = 1;
    if (a == 1) { // 需用小括号包裹条件表达式
        printf("%d\n", a);
    }

    int b = f();
    switch (b) { // 需用小括号包裹条件表达式
    case 4:
        printf("b = 4\n");
        break;
    case 5:
        printf("b = 5\n");
        break;
    default:
        printf("b = n/a\n");
    }

    int i = 0;
    for (i = 1; i < 10; i++) { // 需用小括号包裹循环语句的循环表达式
        a += i;
    }
    printf("%d\n", a);
}

第五,留意C与Go导出符号的不同机制

C语言通过头文件来声明对外可见的符号,所以我们不用管符号是不是首字母大写的。但在Go中,只有首字母大写的包级变量、常量、类型、函数、方法才是可导出的,即对外部包可见。反之,首字母小写的则为包私有的,仅在包内使用。Gopher一旦习惯了这样的规则,在切换到C语言时,就会产生“心理后遗症”:遇到在其他头文件中定义的首字母小写的函数时,总以为不能直接使用。

第六,记得在switch case语句中添加break

C 语言与Go语言在选择分支语句的语义方面有所不同:C语言的 case 语句中,如果没有显式加入break语句,那么代码将向下自动掉落执行。而Go在最初设计时就重新规定了switch case的语义,默认不自动掉落(fallthrough),除非开发者显式使用fallthrough关键字。

适应了Go的switch case语句的语义后再回来写C代码,就会存在潜在的“风险”。我们来看一个例子:

// C代码:
int main() {
    int a = 1;
    switch(a) {
        case 1:printf("a = 1\n");
        case 2:printf("a = 2\n");
        case 3:printf("a = 3\n");
        default:printf("a = ?\n");
    }
}

这段代码是按Go语义编写的switch case,编译运行后得到的结果如下:

a = 1
a = 2
a = 3
a = ?

这显然不符合我们输出“a = 1”的预期。对于初学C的Gopher而言,这个问题影响还是蛮大的,因为这样编写的代码在C编译器眼中是完全合法的,但所代表的语义却完全不是开发人员想要的。这样的程序一旦流入到生产环境,其缺陷可能会引发生产故障。

一些Clint 工具可以检测出这样的问题,因此对于写C代码的Gopher,我建议在提交代码前使用lint工具对代码做一下检查。

4. 构建机制

Go与C都是静态编译型语言,它们的源码需要经过编译器和链接器处理,这个过程称为构建(build),构建后得到的可执行文件才是最终交付给用户的成果物。

和Go语言略有不同的是,C语言的构建还有一个预处理(pre-processing)阶段,预处理环节的输出才是C编译器的真正输入。C语言中的宏就是在预处理阶段展开的。不过,Go没有预处理阶段。

C语言的编译单元是一个C源文件(.c),每个编译单元在编译过程中会对应生成一个目标文件(.o/.obj),最后链接器将这些目标文件链接在一起,形成可执行文件。

而Go则是以一个包(package)为编译单元的,每个包内的源文件生成一个.o文件,一个包的所有.o文件聚合(archive)成一个.a文件,链接器将这些目标文件链接在一起形成可执行文件。

Go语言提供了统一的Go命令行工具链,且Go编译器原生支持增量构建,源码构建过程不需要Gopher手工做什么配置。但在C语言的世界中,用于构建C程序的工具有很多,主流的包括gcc/clang,以及微软平台的C编译器。这些编译器原生不支持增量构建,为了提升工程级构建的效率,避免每次都进行全量构建,我们通常会使用第三方的构建管理工具,比如make(Makefile)或CMake。考虑移植性时,我们还会使用到configure文件,用于在目标机器上收集和设置编译器所需的环境信息。

5. 依赖管理

我在前面提过,C语言仅提供了一个“小内核”。像依赖管理这类的事情,C语言本身并没有提供跟Go中的Go Module类似的,统一且相对完善的解决方案。在C语言的世界中,我们依然要靠外部工具(比如CMake)来管理第三方的依赖。

C语言的第三方依赖通常以静态库(.a)或动态共享库(.so)的形式存在。如果你的应用要使用静态链接,那就必须在系统中为C编译器提供第三方依赖的静态库文件。但在实际工作中,完全采用静态链接有时是会遇到麻烦的。这是因为,很多操作系统在默认安装时是不带开发包的,也就是说,像 libc、libpthread 这样的系统库只提供了动态共享库版本(如/lib下提供了libc的共享库libc.so.6),其静态库版本是需要自行下载、编译和安装的(如libc的静态库libc.a在安装后是放在/usr/lib下面的)。所以多数情况下,我们是将****静态、动态****两种链接方式混合在一起使用的,比如像libc这样的系统库多采用动态链接。

动态共享库通常是有版本的,并且按照一定规则安装到系统中。举个例子,一个名为libfoo的动态共享库,在安装的目录下文件集合通常是这样:

2022-03-10 12:28 libfoo.so -> libfoo.so.0.0.0*
2022-03-10 12:28 libfoo.so.0 -> libfoo.so.0.0.0*
2022-03-10 12:28 libfoo.so.0.0.0*

按惯例,每个动态共享库都有多个名字属性,包括real name、soname和linker name。下面我们来分别看下。

  • real name:实际包含共享库代码的那个文件的名字(如上面例子中的libfoo.so.0.0.0)。动态共享库的真实版本信息就在real name中,显然real name中的版本号符合语义版本规范,即major.minor.patch。当两个版本的major号一致,说明是向后兼容的两个版本;
  • soname:shared object name的缩写,也是这三个名字中最重要的一个。无论是在编译阶段还是在运行阶段,系统链接器都是通过动态共享库的soname(如上面例子中的libfoo.so.0)来唯一识别共享库的。我们看到的soname实际上是仅包含major号的共享库名字;
  • linker name:编译阶段提供给编译器的名字(如上面例子中的libfoo.so)。如果你构建的共享库的real name跟上面例子中libfoo.so.0.0.0类似,带有版本号,那么你在编译器命令中直接使用-L path -lfoo是无法让链接器找到对应的共享库文件的,除非你为libfoo.so.0.0.0提供了一个linker name(如libfoo.so,一个指向libfoo.so.0.0.0的符号链接)。linker name一般在共享库安装时手工创建。
    动态共享库有了这三个名称属性,依赖管理就有了依据。但由于在链接的时候使用的是linker name,而linker name并不带有版本号,真实版本与主机环境有关,因此要实现C应用的可重现构建还是比较难。在实践中,我们通常会使用专门的构建主机,项目组将该主机上的依赖管理起来,进而保证每次构建所使用的依赖版本是可控的。同时,应用部署的目标主机上的依赖版本也应该得到管理,避免运行时出现动态共享库版本不匹配的问题。

6. 代码风格

Go语言是历史上首次实现了代码风格全社区统一的编程语言。它基本上消除了开发人员在代码风格上的无休止的、始终无法达成一致的争论,以及不同代码风格带来的阅读、维护他人代码时的低效。gofmt工具格式化出来的代码风格已经成为Go开发者的一种共识,融入到Go语言的开发文化当中了。所以,如果你让某个Go开发者说说gofmt后的代码风格是什么样的,多数Go开发者可能说不出,因为代码会被gofmt自动变成那种风格,大家已经不再关心风格了。

而在C语言的世界,代码风格仍存争议。但经过多年的演进,以及像Go这样新兴语言的不断“教育”,C社区也在尝试进行这方面的改进,涌现出了像clang-format这样的工具。目前,虽然还没有在全社区达成一致的代码风格(由于历史原因,这很难做到),但已经可以减少很多不必要的争论。

对于正在学习C语言,并进行C编码实践的Gopher,我的建议是:不要拘泥于使用什么代码风格,先用clang-format,并确定一套风格模板就好

四. 小结

作为一名对Go跟随和研究了近十年的程序员,我深刻体会到,Go的简单性、性能和生产力使它成为了创建面向用户的应用程序和服务的理想语言。快速的迭代让团队能够快速地作出反应,以满足用户不断变化的需求,让团队可以将更多精力集中在保持灵活性上。

但Go也有缺点,比如缺少对内存以及一些低级操作的精确控制,而C语言恰好可以弥补这个缺陷。C 语言提供的更精细的控制允许更多的精确性,使得C成为低级操作的理想语言。这些低级操作不太可能发生变化,并且C相比Go还提高了性能。所以,如果你是一个有性能与低级操作需求的 Gopher ,就有充分的理由来学习C语言。

C 的优势体现在最接近底层机器的地方,而Go的优势在离用户较近的地方能得到最大发挥。当然,这并不是说两者都不能在对方的空间里工作,但这样做会增加“摩擦”。当你的需求从追求灵活性转变为注重效率时,用C重写库或服务的理由就更充分了。

总之,虽然Go和C的设计有很大的不同,但它们也有很多相似性,具备发挥兼容优势的基础。并且,当我们同时使用这二者时,就可以既有很大的灵活性,又有很好的性能,可以说是相得益彰!

五. 写在最后

今天的加餐中,我主要是基于C与Go的比较来讲解的,对于Go语言的特性并没有作详细展开。如果你还想进一步了解Go语言的设计哲学、语法特性、程序设计相关知识,欢迎来学习我在极客时间上的专栏《Tony Bai ·Go语言第一课》。在这门课里,我会用我十年Gopher的经验,带给你一条系统、完整的Go语言入门路径。

感谢你看到这里,如果今天的内容让你有所收获,欢迎把它分享给你的朋友。


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

img{512x368}
img{512x368}

img{512x368}
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
  • 微信公众号:iamtonybai
  • 博客:tonybai.com
  • github: https://github.com/bigwhite
  • “Gopher部落”知识星球:https://public.zsxq.com/groups/51284458844544

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

如发现本站页面被黑,比如:挂载广告、挖矿等恶意代码,请朋友们及时联系我。十分感谢! Go语言第一课 Go语言精进之路1 Go语言精进之路2 Go语言编程指南
商务合作请联系bigwhite.cn AT aliyun.com

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

输入邮箱订阅本站,只要有新文章发布,就会第一时间发送邮件通知你哦!

这里是 Tony Bai的个人Blog,欢迎访问、订阅和留言! 订阅Feed请点击上面图片

如果您觉得这里的文章对您有帮助,请扫描上方二维码进行捐赠 ,加油后的Tony Bai将会为您呈现更多精彩的文章,谢谢!

如果您希望通过微信捐赠,请用微信客户端扫描下方赞赏码:

如果您希望通过比特币或以太币捐赠,可以扫描下方二维码:

比特币:

以太币:

如果您喜欢通过微信浏览本站内容,可以扫描下方二维码,订阅本站官方微信订阅号“iamtonybai”;点击二维码,可直达本人官方微博主页^_^:
本站Powered by Digital Ocean VPS。
选择Digital Ocean VPS主机,即可获得10美元现金充值,可 免费使用两个月哟! 著名主机提供商Linode 10$优惠码:linode10,在 这里注册即可免费获 得。阿里云推荐码: 1WFZ0V立享9折!


View Tony Bai's profile on LinkedIn
DigitalOcean Referral Badge

文章

评论

  • 正在加载...

分类

标签

归档



View My Stats