在很多场所,经常使用Go言语须要调用外部命令来成功一些特定的义务,例如:经常使用Go言语调用命令来失掉口头的结果,又或许调用第三方程序口头来成功额外的义务。在go的规范库中,专门提供了os/exec包来对调用外部程序提供允许,本文将对调用外部命令罕用的几种场景启动总结。

间接调用函数

假设要经常使用Go代码调用该命令,可以经常使用以下代码:

funcmn(){cmd:=exec.Command("cal")err:=cmd.Run()iferr!=nil{fmt.Println(err.Error())}}

首先,调用"os/exec"包中的Command函数,并传入命令称号作为参数,Command函数会前往一个exec.Cmd的命令对象。接着调用该命令对象的Run()方法运转命令。

假设此时运转程序,会发现什么都没有出现,这是由于咱们没有处置规范输入,调用os/exec口头命令,规范输入和规范失误自动会被摈弃。

这里将cmd结构中的Stdout和Stderr区分设置为os.stdout和os.Stderr,代码如下：

funcmain(){cmd:=exec.Command("cal")cmd.Stdout=os.Stdoutcmd.Stderr=os.Stderrerr:=cmd.Run()iferr!=nil{fmt.Println(err.Error())}}

运转程序后显示:

输入到文件

输入到文件的关键,是将exec.Cmd对象的Stdout和Stderr赋值文件句柄,代码如下:

funcmain(){f,err:=os.OpenFile("sample.txt",os.O_WRONLY|os.O_CREATE,os.ModePerm)iferr!=nil{fmt.Println(err.Error())}cmd:=exec.Command("cal")cmd.Stdout=fcmd.Stderr=ferr:=cmd.Run()iferr!=nil{fmt.Println(err.Error())}}

os.OpenFile关上一个文件,指定os.0_CREATE标记让操作系统在文件不存在时智能创立,前往文件对象*os.File,*os.File成功了io.Writer接口。

运转程序结果如下:

发送到网络

这里开启一个HTTP服务,服务端接纳两个参数:年和月,在服务端经过口头系统命令前往结果,代码如下:

import("fmt""/http""os/exec")funcqueryDate(whttp.ResponseWriter,r*http.Request){varerrerrorifr.Method=="GET"{year:=r.URL.Query().Get("year")month:=r.URL.Query().Get("month")cmd:=exec.Command("cal",month,year)cmd.Stdout=wcmd.Stderr=werr=cmd.Run()iferr!=nil{fmt.Println(err.Error())}}}funcmain(){http.HandleFunc("/querydate",queryDate)http.ListenAndServe(":8001",nil)}

关上阅读器,在地址栏中输入URL查问2023年10月份的日历：结果如下:

输入到多个指标

假设要将口头命令的结果同时输入到文件、网络和内存对象,可以经常使用io.MultiWriter满足需求,io.MultiWriter可以很繁难的将多个io.Writer转换成一个io.Writer,修正之前的Web服务端程序如下:

funcqueryDate(whttp.ResponseWriter,r*http.Request){varerrerrorifr.Method=="GET"{buffer:=bytes.NewBuffer(nil)year:=r.URL.Query().Get("year")month:=r.URL.Query().Get("month")f,_:=os.OpenFile("sample.txt",os.O_WRONLY|os.O_CREATE,os.ModePerm)mw:=io.MultiWriter(w,f,buffer)cmd:=exec.Command("cal",month,year)cmd.Stdout=mwcmd.Stderr=mwerr=cmd.Run()iferr!=nil{fmt.Println(err.Error())}fmt.Println(buffer.String())}}funcmain(){http.HandleFunc("/querydate",queryDate)http.ListenAndServe(":8001",nil)}

区分失掉输入内容和失误

这里咱们封装一个罕用函数,输入接纳命令和多个参数,前往失误和命令前往消息,函数代码如下:

funcExecCommandOneTimeOutput(namestring,args...string)(error,string){varoutbytes.Buffervarstderrbytes.Buffercmd:=exec.Command(name,args...)cmd.Stdout=&outcmd.Stderr=&stderrerr:=cmd.Run()iferr!=nil{fmt.Println(fmt.Sprint(err)+":"+stderr.String())returnerr,""}returnnil,out.String()}

该函数可以作为通用的命令口头前往结果的函数,区分前往了失误和命令前往消息。

循环失掉命令内容

在Linux系统中,有些命令运转后结果是灵活继续降级的,例如:top命令,关于该场景,咱们封装函数如下:

funcExecCommandLoopTimeOutput(namestring,args...string)<-chanstruct{}{cmd:=exec.Command(name,args...)closed:=make(chanstruct{})deferclose(closed)stdoutPipe,err:=cmd.StdoutPipe()iferr!=nil{fmt.Println(err.Error())}deferstdoutPipe.Close()gofunc(){scanner:=bufio.NewScanner(stdoutPipe)forscanner.Scan(){fmt.Println(string(scanner.Bytes()))_,err:=simplifiedchinese.GB18030.NewDecoder().Bytes(scanner.Bytes())iferr!=nil{continue}}}()iferr:=cmd.Run();err!=nil{fmt.Println(err.Error())}returnclosed}

经过调用cmd对象的StdoutPipe()输入治理函数,咱们可以成功继续失掉后盾命令前往的结果,并坚持程序不分开。

在调用该函数的时刻,调用形式如下:

<-ExecCommandLoopTimeOutput("top")

打印出的消息将是一个继续显示消息,如图:

总结

本章节引见了经常使用os/exec这个规范库调用外部命令的各种场景。在实践运行中,基本用的最多的还是封装好的:ExecCommandOneTimeOutput()和ExecCommandLoopTimeOutput()两个函数,毕竟外部命令普通只会蕴含两种:一种是口头后马上失掉结果，第二种就是常驻内存继续失掉结果。

GO语言商业案例（十八）：stream

切换到新语言始终是一大步，尤其是当您的团队成员只有一个时有该语言的先前经验。现在，Stream 的主要编程语言从 Python 切换到了 Go。这篇文章将解释stream决定放弃 Python 并转向 Go 的一些原因。

Go 非常快。性能类似于 Java 或 C++。对于用例，Go 通常比 Python 快 40 倍。

对于许多应用程序来说，编程语言只是应用程序和数据库之间的粘合剂。语言本身的性能通常并不重要。然而，Stream 是一个API 提供商，为 700 家公司和超过 5 亿最终用户提供提要和聊天平台。多年来，我们一直在优化 Cassandra、PostgreSQL、Redis 等，但最终，您会达到所使用语言的极限。Python 是一门很棒的语言，但对于序列化/反序列化、排名和聚合等用例，它的性能相当缓慢。我们经常遇到性能问题，Cassandra 需要 1 毫秒来检索数据，而 Python 会花费接下来的 10 毫秒将其转换为对象。

看看我如何开始 Go 教程中的一小段 Go 代码。（这是一个很棒的教程，也是学习 Go 的一个很好的起点。）

如果您是 Go 新手，那么在阅读那个小代码片段时不会有太多让您感到惊讶的事情。它展示了多个赋值、数据结构、指针、格式和一个内置的 HTTP 库。当我第一次开始编程时，我一直喜欢使用 Python 更高级的功能。Python 允许您在编写代码时获得相当的创意。例如，您可以：

这些功能玩起来很有趣，但是，正如大多数程序员会同意的那样，在阅读别人的作品时，它们通常会使代码更难理解。Go 迫使你坚持基础。这使得阅读任何人的代码并立即了解发生了什么变得非常容易。 注意：当然，它实际上有多“容易”取决于您的用例。如果你想创建一个基本的 CRUD API，我仍然推荐 Django + DRF或 Rails。

作为一门语言，Go 试图让事情变得简单。它没有引入许多新概念。重点是创建一种非常快速且易于使用的简单语言。它唯一具有创新性的领域是 goroutine 和通道。（100% 正确CSP的概念始于 1977 年，所以这项创新更多是对旧思想的一种新方法。）Goroutines 是 Go 的轻量级线程方法，通道是 goroutines 之间通信的首选方式。Goroutines 的创建非常便宜，并且只需要几 KB 的额外内存。因为 Goroutine 非常轻量，所以有可能同时运行数百甚至数千个。您可以使用通道在 goroutine 之间进行通信。Go 运行时处理所有复杂性。goroutines 和基于通道的并发方法使得使用所有可用的 CPU 内核和处理并发 IO 变得非常容易——所有这些都不会使开发复杂化。与 Python/Java 相比，在 goroutine 上运行函数需要最少的样板代码。您只需在函数调用前加上关键字“go”：

Go 的并发方法很容易使用。与 Node 相比，这是一种有趣的方法，开发人员必须密切关注异步代码的处理方式。Go 中并发的另一个重要方面是竞争检测器。这样可以很容易地确定异步代码中是否存在任何竞争条件。

我们目前用 Go 编写的最大的微服务编译需要 4 秒。与以编译速度慢而闻名的 Java 和 C++ 等语言相比，Go 的快速编译时间是一项重大的生产力胜利。我喜欢在程序编译的时候摸鱼，但在我还记得代码应该做什么的同时完成事情会更好。

首先，让我们从显而易见的开始：与 C++ 和 Java 等旧语言相比，Go 开发人员的数量并不多。根据StackOverflow的数据， 38% 的开发人员知道 Java， 19.3% 的人知道 C++，只有 4.6% 的人知道 Go。GitHub 数据显示了类似的趋势：Go 比 Erlang、Scala 和 Elixir 等语言使用更广泛，但不如 Java 和 C++ 流行。幸运的是，Go 是一种非常简单易学的语言。它提供了您需要的基本功能，仅此而已。它引入的新概念是“延迟”声明和内置的并发管理与“goroutines”和通道。（对于纯粹主义者来说：Go 并不是第一种实现这些概念的语言，只是第一种使它们流行起来的语言。）任何加入团队的 Python、Elixir、C++、Scala 或 Java 开发人员都可以在一个月内在 Go 上发挥作用，因为它的简单性。与许多其他语言相比，我们发现组建 Go 开发人员团队更容易。如果您在博尔德和阿姆斯特丹等竞争激烈的生态系统中招聘人员，这是一项重要的优势。

对于我们这样规模的团队（约 20 人）来说，生态系统很重要。如果您必须重新发明每一个小功能，您根本无法为您的客户创造价值。Go 对我们使用的工具有很好的支持。实体库已经可用于 Redis、RabbitMQ、PostgreSQL、模板解析、任务调度、表达式解析和 RocksDB。与 Rust 或 Elixir 等其他较新的语言相比，Go 的生态系统是一个重大胜利。它当然不如 Java、Python 或 Node 之类的语言好，但它很可靠，而且对于许多基本需求，你会发现已经有高质量的包可用。

Gofmt 是一个很棒的命令行实用程序，内置在 Go 编译器中，用于格式化代码。就功能而言，它与 Python 的 autopep8 非常相似。我们大多数人并不真正喜欢争论制表符与空格。格式的一致性很重要，但实际的格式标准并不那么重要。Gofmt 通过使用一种正式的方式来格式化您的代码来避免所有这些讨论。

Go 对协议缓冲区和 gRPC 具有一流的支持。这两个工具非常适合构建需要通过 RPC 通信的微服务。您只需要编写一个清单，在其中定义可以进行的 RPC 调用以及它们采用的参数。然后从这个清单中自动生成服务器和客户端代码。生成的代码既快速又具有非常小的网络占用空间并且易于使用。从同一个清单中，您甚至可以为许多不同的语言生成客户端代码，例如 C++、Java、Python 和 Ruby。因此，内部流量不再有模棱两可的 REST 端点，您每次都必须编写几乎相同的客户端和服务器代码。.

Go 没有像 Rails 用于 Ruby、Django 用于 Python 或 Laravel 用于 PHP 那样的单一主导框架。这是 Go 社区内激烈争论的话题，因为许多人主张你不应该一开始就使用框架。我完全同意这对于某些用例是正确的。但是，如果有人想构建一个简单的 CRUD API，他们将更容易使用 Django/DJRF、Rails Laravel 或Phoenix。对于 Stream 的用例，我们更喜欢不使用框架。然而，对于许多希望提供简单 CRUD API 的新项目来说，缺乏主导框架将是一个严重的劣势。

Go 通过简单地从函数返回错误并期望调用代码来处理错误（或将其返回到调用堆栈）来处理错误。虽然这种方法有效，但很容易失去问题的范围，以确保您可以向用户提供有意义的错误。错误包通过允许您向错误添加上下文和堆栈跟踪来解决此问题。另一个问题是很容易忘记处理错误。像 errcheck 和 megacheck 这样的静态分析工具可以方便地避免犯这些错误。虽然这些变通办法效果很好，但感觉不太对劲。您希望该语言支持正确的错误处理。

Go 的包管理绝不是完美的。默认情况下，它无法指定特定版本的依赖项，也无法创建可重现的构建。Python、Node 和 Ruby 都有更好的包管理系统。但是，使用正确的工具，Go 的包管理工作得很好。您可以使用Dep来管理您的依赖项，以允许指定和固定版本。除此之外，我们还贡献了一个名为的开源工具VirtualGo，它可以更轻松地处理用 Go 编写的多个项目。

我们进行的一个有趣的实验是在 Python 中使用我们的排名提要功能并在 Go 中重写它。看看这个排名方法的例子：

Python 和 Go 代码都需要执行以下操作来支持这种排名方法：

开发 Python 版本的排名代码大约花了 3 天时间。这包括编写代码、单元测试和文档。接下来，我们花了大约 2 周的时间优化代码。其中一项优化是将分数表达式 (simple_gauss(time)*popularity) 转换为抽象语法树. 我们还实现了缓存逻辑，可以在未来的特定时间预先计算分数。相比之下，开发此代码的 Go 版本大约需要 4 天时间。性能不需要任何进一步的优化。因此，虽然 Python 的最初开发速度更快，但基于 Go 的版本最终需要我们团队的工作量大大减少。另外一个好处是，Go 代码的执行速度比我们高度优化的 Python 代码快大约 40 倍。现在，这只是我们通过切换到 Go 体验到的性能提升的一个示例。

与 Python 相比，我们系统的其他一些组件在 Go 中构建所需的时间要多得多。作为一个总体趋势，我们看到 开发 Go 代码需要更多的努力。但是，我们花更少的时间 优化 代码以提高性能。

我们评估的另一种语言是Elixir.。Elixir 建立在 Erlang 虚拟机之上。这是一种迷人的语言，我们之所以考虑它，是因为我们的一名团队成员在 Erlang 方面拥有丰富的经验。对于我们的用例，我们注意到 Go 的原始性能要好得多。Go 和 Elixir 都可以很好地服务数千个并发请求。但是，如果您查看单个请求的性能，Go 对于我们的用例来说要快得多。我们选择 Go 而不是 Elixir 的另一个原因是生态系统。对于我们需要的组件，Go 有更成熟的库，而在许多情况下，Elixir 库还没有准备好用于生产环境。培训/寻找开发人员使用 Elixir 也更加困难。这些原因使天平向 Go 倾斜。Elixir 的 Phoenix 框架看起来很棒，绝对值得一看。

Go 是一种非常高性能的语言，对并发有很好的支持。它几乎与 C++ 和 Java 等语言一样快。虽然与 Python 或 Ruby 相比，使用 Go 构建东西确实需要更多时间，但您将节省大量用于优化代码的时间。我们在Stream有一个小型开发团队，为超过 5 亿最终用户提供动力和聊天。Go 结合了 强大的生态系统 、新开发人员的 轻松入门、快速的性能 、对并发的 可靠支持和高效的编程环境 ，使其成为一个不错的选择。Stream 仍然在我们的仪表板、站点和机器学习中利用 Python 来提供个性化的订阅源. 我们不会很快与 Python 说再见，但今后所有性能密集型代码都将使用 Go 编写。我们新的聊天 API也完全用 Go 编写。

深入剖析：一套在 Go 中传递、返回、暴露错误，便于回查的解决方案

作者：andruzhang，腾讯 IEG 后台开发工程师

在后台开发中，针对错误处理，有三个维度的问题需要解决：

一个面向过程的函数，在不同的处理过程中需要 handle 不同的错误信息；一个面向对象的函数，针对一个操作所返回的不同类型的错误，有可能需要进行不同的处理。此外，在遇到错误时，也可以使用断言的方式，快速中止函数流程，大大提高代码的可读性。

在许多高级语言中都提供了 try ... catch 的语法，函数内部可以通过这种方案，实现一个统一的错误处理逻辑。而即便是 C 这种 “中级语言” 虽然没有，但是程序员也可以使用宏定义的方式，来实现某种程度上的错误断言。

但是，对于 Go 的情况就比较尴尬了。

我们先来看断言，我们的目的是，仅使用一行代码就能够检查错误并终止当前函数。由于没有 throw，没有宏，如果要实现一行断言，有两种方法。

第一种是把 if 的错误判断写在一行内，比如：

第二种方法是借用 panic 函数，结合 recover 来实现:

这两种方法都值得商榷。

首先，将 if 写在同一行内的问题有：

至于第二种方法，我们要分情况看；

不过使用 panic 来断言的方案，虽然在业务逻辑中基本上不用，但在测试场景下则是非常常见的。测试嘛，用牛刀有何不可？稍微大一点的系统开销也没啥问题。对于 Go 来说，非常热门的单元测试框架goconvey 就是使用 panic 机制来实现单元测试中的断言，用的人都说好。

综上，在 Go 中，对于业务代码，笔者不建议采用断言，遇到错误的时候建议还是老老实实采用这种格式：

而在单测代码中，则完全可以大大方方地采用类似于 goconvey 之类基于 panic 机制的断言。

众所周知 Go 是没有 try ... catch 的，而且从官方的态度来看，短时间内也没有考虑的计划。但程序员有这个需求呀。笔者采用的方法，是将需要返回的 err 变量在函数内部全局化，然后结合 defer 统一处理：

这种方案要特别注意变量作用域问题.比如前面的 if err = DoSomething(); err != nil { 行，如果我们将 err = ... 改为 err := ...，那么这一行中的 err 变量和函数最前面定义的 (err error) 不是同一个变量，因此即便在此处发生了错误，但是在 defer 函数中无法捕获到 err 变量了。

在 try ... catch 方面，笔者其实没有特别好的方法来模拟，即便是上面的方法也有一个很让人头疼的问题：defer 写法导致错误处理前置，而正常逻辑后置了，从可读性的角度来说非常不友好。因此也希望读者能够指教。同时还是希望 Go 官方能够继续迭代，支持这种语法。

这一点在 Go 里面，一开始看起来还是比较统一的，这就是 Go 最开始就定义的 error 类型，以系统标准的方式，统一了进程内函数级的错误返回模式。调用方使用 if err != nil 的统一模式，来判断一个调用是不是成功了。

但是随着 Go 的逐步推广，由于 error 接口的高自由度，程序员们对于 “如何判断该错误是什么错误” 的时候，出现了分歧。

在 Go 1.13 之前，对于 error 类型的传递，有三种常见的模式：

这个流派很简单，就是将各种错误信息直接定义为一个类枚举值的模式，比如：

当遇到相应的错误信息时，直接返回对应的 error 类枚举值就行了。对于调用方也非常方便，可以采用 switch - case 来判断错误类型：

个人觉得这种设计模式本质上还是 C error code 模式。

这种流派则是充分使用了 “error 是一个 interface” 的特性，重新自定义一个 error 类型。一方面是用不同的类型来表示不同的错误分类，另一方面则能够实现对于同一错误类型，能够给调用方提供更佳详尽的信息。举个例子，我们可以定义多个不同的错误类型如下：

对于调用方，则通过以下代码来判断不同的错误：

这种模式，一方面可以透传底层错误，另一方面又可以添加自定义的信息。但对于调用方而言，灾难在于如果要判断某一个错误的具体类型，只能用 () 来实现，而错误的具体描述文字是不可靠的，同一类型的信息可能会有不同的表达；而在 的过程中，各个业务添加的额外信息也可能会有不同的文字，这带来了极大的不可靠性，提高了模块之间的耦合度。

在 go 1.13 版本发布之后，针对 增加了 wraping 功能，并在 errors 包中添加了 Is() 和 As() 函数。关于这个模式的原理和使用已经有很多文章了，本文就不再赘述。

这个功能，合并并改造了前文的所谓 “== 流派” 和 “” 流派，统一使用 () 函数；此外，也算是官方对类型断言流派的认可（专门用 As() 函数来支持）。

在实际应用中，函数/模块透传错误时，应该采用 Go 的 error wrapping 模式，也就是 () 配合 %w 使用，业务方可以放心地添加自己的错误信息，只要调用方统一采用 () 和 () 即可。

服务/系统层面的错误信息返回，大部分协议都可以看成是 code - message 模式或者是其变体：

这种模式的特点是：code 是给程序代码使用的，代码判断这是一个什么类型的错误，进入相应的分支处理；而 message 是给人看的，程序可以以某种形式抛出或者记录这个错误信息，供用户查看。

在这一层面有什么问题呢？code for computer，message for user，好像挺好的。

但有时候，我们可能会收到用户/客户反馈一个问题：“XXX 报错了，帮忙看看什么问题？”。用户看不懂我们的错误提示吗？

在笔者的经验中，我们在使用 code - message 机制的时候，特别是业务初期，难以避免的是前后端的设计文案没能完整地覆盖所有的错误用例，或者是错误极其罕见。因此当出现错误时，提示暧昧不清（甚至是直接提示错误信息），导致用户从错误信息中找到解决方案

在这种情况下，尽量覆盖所有错误路径肯定是最完美的方法。不过在做到这一点之前，码农们往往有下面的解决方案：

既要隐藏信息，又要暴露信息，我可以摔盘子吗……

这里，笔者从日益普及的短信验证码有了个灵感——人的短期记忆对 4 个字符还是比较强的，因此我们可以考虑把错误代码缩短到 4 个字符——不区分大小写，因为如果人在记忆时还要记录大小写的话，难度会增加不少。

怎么用 4 个字符表示尽量多的数据呢？数字+字母总共有 36 个字符，理论上使用 4 位 36 进制可以表示 36x36x36x36 = 个值。因此我们只要找到一个针对错误信息字符串的哈希算法，把输出值限制在 范围内就行了。

这里我采用的是 MD5 作为例子。MD5 的输出是 128 位，理论上我可以取 MD5 的输出，模 就可以得到一个简易的结果。实际上为了减少除法运算，我采用的是取高 20 位（0xFFFFF）的简易方式（20 位二进制的最大值为 ），然后将这个数字转成 36 进制的字符串输出。

当出现异常错误时，我们可以将 message 的提示信息如下展示：“未知错误，错误代码 30EV，如需协助，请联系 XXX”。顺带一提，30EV 是 Access denied for user db_user@127.0.0.1 的计算结果，这样一来，我就对调用方隐藏了敏感信息。

至于后台侧，还是需要实实在在地将这个哈希值和具体的错误信息记录在日志或者其他支持搜索的渠道里。当用户提供该代码时，可以快速定位。

这种方案的优点很明显：

简易的错误码生成代码如下：

当然这种方案也有局限性，笔者能想到的是需要注意以下两点：

此外，笔者需要再强调的是：在开发中，针对各种不同的、正式的错误用例依然需要完整覆盖，尽可能通过已有的 code - message 机制将足够清晰的信息告知主调方。这种 hashcode 的错误代码生成方法，仅适用于错误用例遗漏、或者是快速迭代过程中，用于发现和调试遗漏的错误用例的临时方案。