golang 命令行

by Peter Benjamin

彼得·本杰明(Peter Benjamin)

如何使用Golang编写快速有趣的命令行应用程序 How to write fast, fun command-line applications with Golang

A while back, I wrote an article about “Writing Command-Line Applications in NodeJS”.

不久前，我写了一篇有关“ 在NodeJS中编写命令行应用程序 ”的文章。

I love JavaScript, Node.JS, npm, and the whole ecosystem. To me, nothing feels more natural than writing modern JavaScript applications with ES6 or TypeScript.

我喜欢JavaScript，Node.JS，npm和整个生态系统。 对我来说，没有什么比使用ES6或TypeScript编写现代JavaScript应用程序更自然的了。

But, lately, I’ve needed to leverage multi-processor (parallel) concurrency. Due to NodeJS’s single-threaded event loop, NodeJS is concurrent, but not parallel. NodeJS does not support parallel concurrency “out of the box”.

但是，最近，我需要利用多处理器(并行)并发。 由于NodeJS的单线程事件循环，NodeJS是并发的，但不是并行的。 NodeJS不支持“开箱即用”的并行并发。

为什么去？ (Why Go?)

The Go language (often referred to as “Golang”), will utilize all cores of a machine by default. Go also brings the following benefits:

Go语言(通常称为“ Golang”)在默认情况下将利用计算机的所有内核。 Go还带来以下好处：

  • Type safety (e.g. you cannot pass a string to a function that’s expecting a number — the compiler will complain) 类型安全性(例如，您不能将字符串传递给需要数字的函数，编译器会抱怨)
  • Easy refactoring (e.g. changing a function or variable name will propagate that change throughout the project) 易于重构(例如，更改函数或变量名称将在整个项目中传播该更改)
  • Speed and performance out-of-the-box 开箱即用的速度和性能
  • Procedural programming paradigm is certainly much easier to reason about 过程编程范例当然更容易推理
  • Easy deployments (just deploy the single binary file and done!) 易于部署(只需部署单个二进制文件并完成！)
  • Standard style (Go is opinionated about formatting and comes with tooling to automate this) 标准样式(Go对格式存有疑虑，并附带可自动执行格式化的工具)
  • … and many more! … 还有很多！

Note: It’s important for new developers not to be intimidated by new concepts. Embrace that uncomfortable feeling you get when you face a new challenge. It means you’re learning, growing, and improving. A key trait of successful developers is persistence.

注意：新开发者不要被新概念吓倒，这一点很重要。 面对新挑战时，您会感到不舒服。 这意味着您正在学习，成长和进步。 成功的开发人员的一个关键特征是坚持不懈 。

Here’s what you’ll learn by following along with this article:

以下是与本文一起学习的内容：

  1. Namespaces 命名空间
  2. Imports 进口货
  3. Variables 变数
  4. Structs 结构
  5. Functions 功能
  6. References and Pointers 参考和指针

  7. If conditions

    如果条件

  8. For loops

    对于循环

入门 (Getting Started)

In order to avoid bloating this article by having to support different commands for 3 different platforms, I will assume that you’re following along on Cloud9. Cloud9 is an online IDE (integrated development environment) — basically, it’s awesome sauce!

为了避免因必须为3个不同的平台支持不同的命令而使本文肿，我假设您正在Cloud9上关注 。 Cloud9是一个在线IDE(集成开发环境)-基本上，这太棒了！

安装 (Install)

Go already comes pre-installed on Cloud9’s blank Ubuntu workspaces. So, you can skip this step.

Go已经预先安装在Cloud9的空白U Buntu工作区中。 因此，您可以跳过此步骤。

If you want to follow along on your local computer, you can download and install Go.

如果要在本地计算机上继续学习，可以下载并安装Go 。

建立 (Setup)

Go requires you to setup your environment in a particular way.

Go要求您以特定方式设置环境。

  • You must have a home for all your Go projects. Go calls this home a workspace. The workspace must contain 3 directories: bin (for binaries), pkg, and src (for source code):

    您必须拥有所有Go项目的家。 Go将此家称为工作区 。 工作空间必须包含3个目录： bin (对于二进制文件)， pkg和src (对于源代码)： 

$ pwd
/home/ubuntu/workspace

$ mkdir {bin,src,pkg}

  • Go assumes that each project lives in its own repository, so we need to further organize our src directory into:

    Go假定每个项目都位于其自己的存储库中，因此我们需要将src目录进一步组织为： 

$ mkdir -p src/github.com/<your_github_username>/<project_name>

Note: If you’re a gitlab or a bitbucket user, simply change github.com with the appropriate name (e.g gitlab.com or bitbucket.org respectively).

注意：如果您是gitlab或bitbucket用户，只需使用适当的名称更改github.com (例如分别为gitlab.com或bitbucket.org )。

There is a reason for this directory structure. Go doesn’t have a centralized code repository, like NPM, or RubyGems. Go can fetch source code from online VCS (version control systems) directly and, when it does, it will download the source code in the correct path. For example, the following command:

此目录结构是有原因的。 Go没有像NPM或RubyGems这样的集中式代码存储库。 Go可以直接从在线VCS(版本控制系统)中获取源代码，并且当这样做时，它将以正确的路径下载源代码。 例如，以下命令： 

$ go get golang.org/x/tools/cmd/goimports

will tell Go to contact golang.org, then download the source under:

会告诉Go联系golang.org，然后在以下位置下载源代码： 

<your_go_workspace>/src/golang.org/x/tools/cmd/goimports

Which, in return, enables Go to find third-party packages and libraries when you import them into your project.

作为回报，当您将它们导入到项目中时，Go可以使Go查找第三方软件包和库。

  • Lastly, we need to setup our GOPATH environment variable. In Cloud9 Ubuntu, just add the following at the end of .bashrc:

    最后，我们需要设置我们的GOPATH环境变量。 在Cloud9 Ubuntu中，只需在.bashrc的末尾添加以下内容： 

# in ~/.bashrc
...
export GOPATH="/home/ubuntu/workspace"
export PATH="$PATH:$GOPATH/bin"

Then, save the file and run the following command in the terminal:

然后，保存文件并在终端中运行以下命令： 

source ~/.bashrc
  • To verify that Go is working on Cloud9 and that our GOPATH is set up correctly: 要验证Go在Cloud9上正常工作，并且我们的GOPATH设置正确，请执行以下操作： 
$ go version
go version go1.6 linux/amd64

$ go get golang.org/x/tools/cmd/goimports
$ goimports --help
usage: goimports [flags] [path ...]
...

For more information on Golang setup, visit the official “Getting Started” doc.

有关Golang设置的更多信息，请访问官方的“入门”文档 。

我们走吧！ (Let’s Go!)

Our Goal: to build a minimal CLI app to query GitHub users.

我们的目标：构建一个最小的CLI应用程序以查询GitHub 用户 。

Let’s create a repo for this project on Github.com. Call it gitgo. Then clone it:

让我们在Github.com上为此项目创建一个仓库。 称之为gitgo 。 然后克隆它： 

$ cd $GOPATH/src/github.com/<your_github_username>
$ git clone git@github.com:<your_github_username>/gitgo.git

Go入门 (A Go primer)

Let’s create our first file, call it main.go, and write the following code (don’t worry, we’ll cover each line):

让我们创建第一个文件，将其命名为main.go ，然后编写以下代码(不用担心，我们将覆盖每一行)： 

package main

import "fmt"

func main() {
    fmt.Println("Hello, World")
}

分解…… (Breaking it down…)

package main
  • This is a namespace declaration. Namespaces are just a way for us to group logic and functionality. You’ll see how namespaces will help us a little bit later. 这是一个名称空间声明。 命名空间只是我们对逻辑和功能进行分组的一种方式。 稍后，您将看到名称空间将如何帮助我们。

  • The word main is a keyword. It tells the GO compiler that our code is intended to run as an application not as a library. The difference is that applications are used directly by our users, whereas libraries can only be imported and used by other pieces of code.

    单词main是一个关键字。 它告诉GO编译器我们的代码旨在作为应用程序而非库运行 。 区别在于应用程序直接由我们的用户使用，而库只能由其他代码段导入和使用。 

Import “fmt”
func main()

  • func is the keyword to define or declare a function in GO.

    func是在GO中定义或声明函数的关键字。

  • The word main is a special keyword in GO. It tells the GO compiler that our application starts here!

    “ main ”一词是GO中的特殊关键字。 它告诉GO编译器我们的应用程序从这里开始！ 

fmt.Println(“Hello, World”)

  • This is pretty self-explanatory. We’re using the Println function from the fmt package we imported earlier to… well… print line.

    这是不言自明的。 我们正在使用之前导入到……好……打印行的fmt包中的Println函数。

Notice that the first letter of function Println is upper-case. This is GO’s way of exporting variables, functions, and other stuff. If the first letter of your function or variable is upper-case, it means you’re making it accessible to external packages or namespaces.

请注意，函数Println的首字母是大写。 这是GO导出变量，函数和其他内容的方式。 如果函数或变量的首字母是大写字母，则意味着您可以通过外部包或名称空间访问它。

让我们运行它！ (Let’s Run It!)

$ go run main.go
Hello, World

Awesome! You’ve written your first GO application.What just happened? Well, GO compiled AND executed the application in memory! Pretty fast, huh?

太棒了！ 您已经编写了第一个GO应用程序。发生了什么？ 好吧，GO编译并在内存中执行了应用程序！ 相当快吧？

让我们建造它！ (Let’s Build It!)

$ go build     # generates executable binary in your local directory 
$ ./gitgo
Hello, World

Sweet! You’ve just built your first GO application. You can send just thatone file to your friends and family and they can run it and get the same results. Of course, if they’re running Windows, this application will not work, because we built it for Linux/Unix. So, let’s build it for Windows:

甜！ 您刚刚构建了第一个GO应用程序。 您可以仅将一个文件发送给您的朋友和家人，他们可以运行该文件并获得相同的结果 。 当然，如果他们正在运行Windows，则此应用程序将无法运行，因为我们是针对Linux / Unix构建的。 因此，让我们为Windows构建它： 

$ GOOS=windows go build -o forecaster.exe main.go

There you go! Now, you’ve created an application for Windows. Pretty neat, huh?

你去！ 现在，您已经为Windows创建了一个应用程序。 很整洁吧？

In fact, you can cross-compile that application to a wide range of platforms (e.g. Windows, Linux, OS X) and architectures (e.g. i386, amd64). You can see the full list here: https://golang.org/doc/install/source#environment

实际上，您可以将该应用程序交叉编译到各种平台(例如Windows，Linux，OS X)和体系结构(例如i386，amd64)。 您可以在此处查看完整列表： https : //golang.org/doc/install/source#environment

让我们安装吧！ (Let’s Install It!)

If you want your application to be accessible from anywhere on your system:

如果您希望可以从系统上的任何位置访问应用程序： 

$ go install

That’s it. Now, you can call your application from anywhere:

而已。 现在，您可以从任何地方调用您的应用程序： 

$ gitgo
Hello, World

At this point, it would be a good idea to check your work into GitHub:

此时，将您的工作签入GitHub是一个好主意： 

$ git add .
$ git commit -am "Add main.go"
$ git push

Awesome! But so far, our application doesn’t do anything really. This exercise was just meant to get our feet wet and give us an idea of what it’s like to code in Go.

太棒了！ 但是到目前为止，我们的应用程序并没有真正做任何事情。 这项练习的目的只是弄湿我们，让我们对使用Go进行编码的感觉有所了解。

现在，让我们深入了解我们的CLI应用程序！ (Now, let’s dive into our CLI app!)

We envision the interaction with our app to look something like

我们设想与应用程序的交互看起来像 

$ gitgo -u pmbenjamin
# or...
$ gitgo --user pmbenjamin,defunkt

Now that we have a direction, let’s start creating those flags.

现在我们有了一个方向，让我们开始创建这些标志。

We could use the flag standard library in Go, but, with trial-and-error and a little bit of Googling, you will discover that the standard flag library does not support the long-flag syntax (via double-dash). It only supports single dashes.

我们可以在Go中使用标记标准库，但是经过反复试验和一点点的Google搜索，您会发现标准标记库不支持长标记语法(通过双破折号)。 它仅支持单破折号。

Luckily, someone already solved this with a GO library. Let’s download it:

幸运的是，已经有人使用GO库解决了这个问题。 让我们下载它： 

$ go get github.com/ogier/pflag

Now, let’s import it in our project:

现在，让我们将其导入我们的项目中： 

import (

    "github.com/ogier/pflag"
)

In GO, the last element of the import statement is the namespace we use to access library’s functions:

在GO中，import语句的最后一个元素是我们用来访问库函数的名称空间： 

func main() {
    pflag.SomeFunction()
}

If we prefer to use a different name, we can alias our package names at import:

如果我们希望使用其他名称，则可以在导入时为包名称加上别名： 

import (

    flag "github.com/ogier/pflag"
)

This will allow us to do:

这将使我们能够： 

func main(){
    flag.SomeFunction()
}

Which is what you see in the official examples.

您可以在官方示例中看到这一点。

Let’s create the variables that will hold the data from the user input:

让我们创建将保存来自用户输入的数据的变量： 

import (...)import (
...
)

// flags
var (
   user  string
)

func main() {
...
}

A couple of things to point out here:

这里有两点要指出： 

func main()func main()func main()func main()stringstring

Now that you’ve declared your variables, let’s declare your flags and bind/map each flag to the appropriate variable:

现在，您已经声明了变量，让我们声明您的标志并将每个标志绑定/映射到适当的变量： 

import (
    ...
)

// flags
var (
    ...
)

func main() {
 flag.Parse()
}

func init() {
 flag.StringVarP(&user, "user", "u", "", "Search Users")
}

分解…… (Breaking it down…)

func init()

  • init is a special function in GO. GO executes applications in the following order:

    init是GO中的特殊功能。 GO按以下顺序执行应用程序：

    1. Imports statements

    1.进口声明

    2. Package-level variables/constants declarations

    2.包级变量/常量声明

    3. init() function

    3. init()函数

    4. main() function (if the project is to be treated as an app)

    4. main()函数(如果将项目视为应用程序)

  • All we are trying to do is initialize the flags once 我们要做的就是将标志初始化一次 
flag.StringVarP(&user, "user", "u", "", "Search Users")
StringVarP()StringVarP()StringVarP()StringVarP()&user&user
flag.Parse()
  • Parse the flags. 解析标志。

让我们测试一下我们的工作… (Let’s test our work…)

$ go run main.go # nothing happens
$ go run main.go --help
Usage of /tmp/go-build375844749/command-line-arguments/_obj/exe/main:
  -u, --user string
        Search Users
exit status 2

Great. It seems to be working.

大。 它似乎正在工作。

Notice the weird /tmp/go-build… path? That’s where our application was compiled and executed dynamically by Go. Let’s build it and test it:

注意到奇怪的/ tmp / go-build…路径了吗？ 那是我们的应用程序由Go动态编译和执行的地方。 让我们对其进行构建并对其进行测试： 

$ go install -v
$ gitgo --help
Usage of gitgo:
  -u, --user string
        Search Users
go installgo buildgo install$GOPATH/pkggo build
go installgo buildgo install$GOPATH/pkggo build

核心逻辑 (Core Logic)

Now that we’ve initialized our flags, let’s start implementing some core functionality:

现在我们已经初始化了标志，让我们开始实现一些核心功能： 

func main() {
 // parse flags
 flag.Parse()
 
 // if user does not supply flags, print usage
 // we can clean this up later by putting this into its own function
  if flag.NFlag() == 0 {
     fmt.Printf("Usage: %s [options]\n", os.Args[0])
     fmt.Println("Options:")
     flag.PrintDefaults()
     os.Exit(1)
  }
  
  users = strings.Split(user, ",")
  fmt.Printf("Searching user(s): %s\n", users)
  
}

Note that there are no parentheses around if conditionals in Go.

请注意， 如果 Go中有条件，则没有括号。

让我们测试一下我们的工作… (Let’s test our work…)

$ go install
# github.com/pmbenjamin/gitgo
./main.go:15: undefined: fmt in fmt.Printf
./main.go:15: undefined: os in os.Args
./main.go:16: undefined: fmt in fmt.Println
./main.go:18: undefined: os in os.Exit
./main.go:21: undefined: fmt in fmt.Printf
./main.go:24: undefined: fmt in fmt.Printf

I intentionally wanted to show you the experience of the Go compiler when it complains that you did something wrong. It’s important that we’re able to understand these error messages to fix our code.

我有意向您展示Go编译器的经验，当它抱怨您做错了什么时。 重要的是我们能够理解这些错误消息以修复我们的代码。 

PrintlnExit
PrintlnExit

Turns out, we just forgot to import some packages! In a normal IDE (e.g. Atom, VS-Code, vim, emacs …etc), there are plugins that you can install in your editor that will dynamically and automatically import any missing packages! So, you don’t have to import them manually. How awesome is that?

原来，我们只是忘了导入一些软件包！ 在普通的IDE中(例如Atom，VS-Code，vim，emacs等)，您可以在编辑器中安装一些插件，这些插件可以动态地自动导入所有丢失的软件包！ 因此，您不必手动导入它们。 那有多棒？ 

goimports
goimports
$ goimports -w main.go # write import stmts back in main.go!

And re-build and re-test app:

并重新构建和重新测试应用程序： 

$ go install

$ gitgo
Usage: gitgo [options]
Options:
  -u, --user string
        Search Users

$ gitgo -u pmbenjamin        
Searching user(s): [pmbenjamin]

Yes! It works!

是! 有用！

What if the user wants to query multiple users?

如果用户要查询多个用户怎么办？ 

$ gitgo -u pmbenjamin,defunkt
Searching user(s): [pmbenjamin defunkt]

That seems to work too!

这似乎也可以！

Now, let’s start getting actual data. It’s always good practice to encapsulate different functionalities into separate functions to keep our code base clean and modular. You can put that function in main.go or in another file. I prefer a separate file, because it will make it our application modular, re-usable, and easily testable.

现在，让我们开始获取实际数据。 将不同的功能封装到单独的功能中始终是一个好习惯，以保持我们的代码库干净和模块化。 您可以将该函数放在main.go或另一个文件中。 我更喜欢一个单独的文件，因为它将使我们的应用程序模块化，可重复使用且易于测试。

For the sake of time, here is the code along with comments to explain.

为了节省时间，下面是代码和注释进行说明。

要点是这样的： (The gist is this:)

user.gouser.goresprespdeferdeferjson.Unmarshaluserjson.Unmarshalusermain.gousersgetUser()main.gousersgetUser()

未来增强 (Future Enhancements)

This project was just a quick introductory guide for beginners. I know this project can be written a bit more efficiently.

该项目只是针对初学者的快速入门指南。 我知道这个项目可以写得更有效率。

In my next article, I plan on diving into new concepts, like concurrency (GoRoutines), channels, testing, vendoring, and writing Go Libraries (instead of applications).

在下一篇文章中，我计划深入研究新概念，例如并发(GoRoutines)，渠道，测试，供应和编写Go库(而不是应用程序)。

In the meantime, the full project code can be found here.

同时，可以在此处找到完整的项目代码。

Feel free to contribute by opening GitHub issues or submitting PRs.

欢迎打开GitHub问题或提交PR进行贡献。

golang 命令行