GCTT:Ollyder Go语言中文网 今天

点击上方蓝色“Go语言中文网”关注，每天一起学 Go

我来给你讲…
1986 年，Knuth 编写了一个程序来演示文学式编程 。
这段程序目的是读取一个文本文件，找到 n 个最常使用的单词，然后有序输出这些单词以及它们的频率。Knuth 写了一个完美的 10 页程序。
Doug Mcllory 看到这里然后写了 tr -cs A-Za-z '\n' | tr A-Z a-z | sort | uniq -c | sort -rn | sed ${1}q 。
现在是 2019 年了，为什么我还要给你们讲一个发生在 33 年前（可能比一些读者出生的还早）的故事呢？计算领域已经发生了很多变化了，是吧？
林迪效应 是指如一个技术或者一个想法之类的一些不易腐烂的东西的未来预期寿命与他们的当前存活时间成正比。太长不看版——老技术还会存在。
如果你不相信的话，看看这些：

  • oh-my-zsh 在 GitHub 上已经快有了 100,000 个 星星了
  • 《命令行中的数据科学》
  • 命令行工具能够比你的 Hadoop 集群快 235 倍
  • …

现在你应该被说服了吧， 让我们来讨论以下怎么使你的 Go 命令行程序变得友好。
本文是 Go语言中文网组织的 GCTT 翻译，发布在 Go语言中文网公众号，转载请联系我们授权。

设计

当你在写命令行应用程序的时候， 试试遵守 基础的 Unix 哲学

  • 模块性规则：编写通过清晰的接口连接起来的简单的部件
  • 组合性规则：设计可以和其他程序连接起来的程序
  • 缄默性规则：当一个程序没有什么特别的事情需要说的时候，它就应该闭嘴

这些规则能指导你编写做一件事的小程序。

  • 用户需要从 REST API 中读取数据的功能 ？他们会将 curl 命令的输出通过管道输入到你的程序中
  • 用户只想要前 n 个结果 ？他们可以把你的程序的输出结果通过管道输入到 head 命令中
  • 用户指向要第二列数据 ？如果你的输出结果以 tab 为分割， 他们就可以把你的输出通过管道输入到 cut 或 awk 命令

如果你没有遵从上述要求 ， 没有结构性的组织你的命令行接口 ， 你可能会像下面这种情况一样的停止。
编写友好的Go命令行应用程序 - 图1

帮助

让我们来假定你们团队有一个叫做 nuke-db 的实用工具 。你忘了怎么调用它然后你：

  1. $ ./nuke-db --help
  2. database nuked (译者注：也就说本意想看使用方式，但却直接执行了)

OMG！
使用 flag 库 ，你可以用额外的两行代码添加对于 --help 的支持。

  1. package main
  2. import (
  3.  "flag" // extra line 1
  4.  "fmt"
  5. )
  6. func main() {
  7.  flag.Parse() // extra line 2
  8.  fmt.Println("database nuked")
  9. }

现在你的程序运行起来是这个样子：

  1. $ ./nuke-db --help
  2. Usage of ./nuke-db:
  3. $ ./nuke-db
  4. database nuked

如果你想提供更多的帮助 ， 使用 flag.Usage

  1. package main
  2. import (
  3.  "flag"
  4.  "fmt"
  5.  "os"
  6. )
  7. var usage = `usage: %s [DATABASE]
  8. Delete all data and tables from DATABASE.
  9. `
  10. func main() {
  11.  flag.Usage = func() {
  12.   fmt.Fprintf(flag.CommandLine.Output(), usage, os.Args[0])
  13.   flag.PrintDefaults()
  14.  }
  15.  flag.Parse()
  16.  fmt.Println("database nuked")
  17. }

现在 ：

  1. $ ./nuke-db --help
  2. usage: ./nuke-db [DATABASE]
  3. Delete all data and tables from DATABASE.

结构化输出

纯文本是通用的接口。然而，当输出变得复杂的时候， 对机器来说处理格式化的输出会更容易。最普遍的一种格式当然是 JSON。
一个打印的好的方式不是使用 fmt.Printf 而是使用你自己的既适合于文本也适合于 JSON 的打印函数。让我们来看一个例子：

  1. package main
  2. import (
  3.  "encoding/json"
  4.  "flag"
  5.  "fmt"
  6.  "log"
  7.  "os"
  8. )
  9. func main() {
  10.  var jsonOut bool
  11.  flag.BoolVar(&jsonOut, "json", false, "output in JSON format")
  12.  flag.Parse()
  13.  if flag.NArg() != 1 {
  14.   log.Fatal("error: wrong number of arguments")
  15.  }
  16.  write := writeText
  17.  if jsonOut {
  18.   write = writeJSON
  19.  }
  20.  fi, err := os.Stat(flag.Arg(0))
  21.  if err != nil {
  22.   log.Fatalf("error: %s\n", err)
  23.  }
  24.  m := map[string]interface{}{
  25.   "size":     fi.Size(),
  26.   "dir":      fi.IsDir(),
  27.   "modified": fi.ModTime(),
  28.   "mode":     fi.Mode(),
  29.  }
  30.  write(m)
  31. }
  32. func writeText(m map[string]interface{}) {
  33.  for k, v := range m {
  34.   fmt.Printf("%s: %v\n", k, v)
  35.  }
  36. }
  37. func writeJSON(m map[string]interface{}) {
  38.  m["mode"] = m["mode"].(os.FileMode).String()
  39.  json.NewEncoder(os.Stdout).Encode(m)
  40. }

那么

  1. $ ./finfo finfo.go
  2. mode: -rw-r--r--
  3. size: 783
  4. dir: false
  5. modified: 2019-11-27 11:49:03.280857863 +0200 IST
  6. $ ./finfo -json finfo.go
  7. {"dir":false,"mode":"-rw-r--r--","modified":"2019-11-27T11:49:03.280857863+02:00","size":783}

处理

有些操作是比较耗时的，一个是他们更快的方法不是优化代码，而是显示一个旋转加载符或者进度条。不要不信我，这有一个来自 Nielsen 的研究 的引用

看到运动的进度条的人们会有更高的满意度体验而且比那些得不到任何反馈的人平均多出三倍的愿意等待时间。

旋转加载

添加一个旋转加载不需要任何特别的库

  1. package main
  2. import (
  3.  "flag"
  4.  "fmt"
  5.  "os"
  6.  "time"
  7. )
  8. var spinChars = `|/-\`
  9. type Spinner struct {
  10.  message string
  11.  i       int
  12. }
  13. func NewSpinner(message string) *Spinner {
  14.  return &Spinner{message: message}
  15. }
  16. func (s *Spinner) Tick() {
  17.  fmt.Printf("%s %c \r", s.message, spinChars[s.i])
  18.  s.i = (s.i + 1) % len(spinChars)
  19. }
  20. func isTTY() bool {
  21.  fi, err := os.Stdout.Stat()
  22.  if err != nil {
  23.   return false
  24.  }
  25.  return fi.Mode()&os.ModeCharDevice != 0
  26. }
  27. func main() {
  28.  flag.Parse()
  29.  s := NewSpinner("working...")
  30.  for i := 0; i < 100; i++ {
  31.   if isTTY() {
  32.    s.Tick()
  33.   }
  34.   time.Sleep(100 * time.Millisecond)
  35.  }
  36. }

运行它你就能看到一个小的旋转加载在运动。

进度条

对于进度条， 你可能需要一个额外的库如 github.com/cheggaaa/pb/v3

  1. package main
  2. import (
  3.  "flag"
  4.  "time"
  5.  "github.com/cheggaaa/pb/v3"
  6. )
  7. func main() {
  8.  flag.Parse()
  9.  count := 100
  10.  bar := pb.StartNew(count)
  11.  for i := 0; i < count; i++ {
  12.   time.Sleep(100 * time.Millisecond)
  13.   bar.Increment()
  14.  }
  15.  bar.Finish()
  16. }

结语

现在差不多 2020 年了，命令行应用程序仍然会存在。它们是自动化的关键，如果写得好，能提供优雅的“类似乐高”的组件来构建复杂的流程。
我希望这篇文章将激励你成为一个命令行之国的好公民。