Go Commands for Golang Developers



Top 40 Go Command Examples for Aspiring Golang Developers

Go is a statically-typed programming language with strong support for concurrency. It is backed by Google and is meant for general-purpose projects like systems application development or web apps. Golang is becoming more and more popular due to its robust feature set and support for the latest programming practices. A large number of companies are looking for active Go developers due to its growing usage in modern applications. Developers can use a number of go commands to increase their programming productivity or workflow management. In this guide, we will discuss some of these commands for aspiring Go devs.

Useful Go Command Examples in Linux

Go provides a suite of useful tools for managing the build process and workflow for programmers. They are invoked by means of a set of simple commands built right into go. We are outlining 40 such useful commands in the following section.

1. Build a Program

The go build command allows developers to build the binary executable for a given program. We have created a simple server program called server.go for demonstrating this. Now, we will build this program using go build.

$ go build server.go

This command will create a binary executable file named server in our go working directory. You can find out the code for the server program from this section of the Golang website. Now, we can run the program like any other Linux command-line tools.

$ ./server

2. Run a Program Without Building It

Developers usually make gradual changes to their programs based on testing. It is inconvenient to build the program each time you make a slight modification. Luckily, go allows us to run a program even without building it in the first place.

$ go run server.go

This command will run the program directly without requiring you to build the source code. It is extremely useful when you are playing around with smaller sub-programs.

3. Display Current GOPATH

Go manages the source codes, objects, and binaries of a program by using the Go Workspace. The root of this workspace is specified by using the GOPATH variable. You can find the current path to your Go Workspace by using the following command.

$ go env GOPATH

This is where you need to put your source files and compiler them. Although you can set up multiple Go Workspaces, it is advised to use one distinct workspace. The sub-command env also provides a lot of other information, as we’ll see later.

4. Set New GOPATH

From Go version 1.8, Unix systems specify the $HOME/go directory as the default GOPATH. However, you can easily change this to a different location using the following simple command.

$ go env -w GOPATH=$HOME/projects/go

This will change your GOPATH to $HOME/projects/go. You can also set the GOPATH by adding the following line to your ~/.bash_profile. Simply open the file using your favorite Linux text editor and append the next line at the end.

export GOPATH=$HOME/projects/go

After saving the file, exit, and run the following command to reflect the changes.

$ source ~/.bash_profile

5. Install Go Packages

Every go program you write or use is part of a go package. Go packages are nothing but a directory that contains some go files inside the /src directory. We can install go packages very easily by using the go install command.

$ go install test-app

When you run this command, go will look for the directory test-app first in $GOROOT/src and then in $GOPATH/src. Once it is found, go will determine the entry point of the package by looking for the package main in the source files. Go will then proceed to install this package and place the test-app binary in the /bin directory of your workspace.

6. Download and Install Packages

Golang has been enjoying growing popularity among a large number of FOSS developers. As a result, a lot of useful programs are being written using go. You can easily download a third-party go package and install it using the following simple command.

$ go get host/example-project
$ go get github.com/fatih/color

This command will download and install the popular color package alongside all its dependencies. You can also update the package in the future by using the -u flag, as shown below.

$ go get -u github.com/fatih/color

7. List Packages Alongside Dependencies

Your Go workspace will grow over time and may house packages that are no longer needed. You can list all installed go packages as well as their dependencies. This will help you determine which packages to remove from your workspace.

$ go list

This go command requires an import path and will provide information on a specific package. To get information on all installed packages, you need to use a special wildcard.

$ go list ./...

Run this command from your GOPATH and go will display all the packages that are installed in your workspace.

8. Fix Go Packages

When you update your go version, programs that use older features may get broken. Go provides a handy tool to fix these programs and rewrite them to use newer features of the language. You will need to use the go fix command to do this.

$ go fix app/app.go

This command will rewrite the app.go file to accommodate newer Go APIs and features. Use the following command to fix entire applications.

$ go tool fix app/

9. Remove Go Objects

Go creates objects files during program builds and stores them in a temporary directory. Plus, many go tools also create various objects that takes storage space. You will want to get rid of the unused objects over time.

$ go clean

It will remove all go objects that are created before running this command. Use the below command to remove all objects for a specific package.

$ go clean -i app/

The -i option of clean will delete all corresponding binaries or archives as well.

10. Display Environment Information

Programmers can easily find information on various go environment variables. The go env command can be used to display all go environment variable in your Linux terminal emulator.

$ go env

It will print out all go variables no matter whether their values are set or not. To print the value of a specific go variable, use the following format.

$ go env VARIABLE
$ go env GOCACHE

We have printed the GOPATH earlier using the above syntax. It is useful for retrieving particular environment variables.

11. Create Bug Reports

Go is a relatively new language and rolls out new features quite often. Although it is designed very carefully, you may sometime face unwanted bugs or problems. Thankfully, it is very convenient to generate bug reports for the go runtime.

$ go bug

When you run the above command, it will open your default browser and create a bug report in Go’s official GitHub repository. It will add all essential information such as system information as well as go configurations.

12. Reformat Package Sources

The Go runtime makes formatting extremely convenient for developers. You can simply fire up your Linux code editor and start writing code without thinking about indentations or alignments. Once done, use the below go command to format your code according to Go’s recommendation.

$ go fmt [packages]
$ go fmt server.go

The second command formats the server.go file. You can also pass in a directory containing a bunch of go files to format them all. Go will use tabs for indentations and spaces for code alignments.

13. Manage Modules

All Go commands have pre-built support for modules. Modules in Go are nothing but a collection of multiple go packages. The go.mod file contains all third-party packages for a Go application. You can easily create this file by using the following command.

$ go mod <command> [arguments]
$ go mod init app

This command will create a go.mod file for our custom app package. It will contain the module name as well as the go version information. The mod utility takes various other commands apart from init. Type the following to view the available options.

$ go help mod

14. Generate Go Files

Golang allows developers to create or update Go source files by using directives within existing sources. The generate command is used for doing this. Although generate is meant for creating or updating Go files, it can be used to perform other tasks as well.

$ go generate [-run regexp] [-n] [-v] [-x] [build flags] [file.go... | packages]

When you run go generate, it will look for directives of the following format in your go source files.

//go:generate command argument...

Generate will run the command once it finds the directive inside your go source. Note that there can be no spaces before or within “//go“.

15. Upgrade Package Dependencies

Earlier, we showed how to install or update packages using the go get utility. However, when working on larger projects, you will often need to update your package dependencies. The following command updates all Go packages that are in your GOPATH.

$ go get -u all

However, you should use different GOPATH for different projects. It will make sure that updating packages in project A wouldn’t break project B. You can also upgrade a package to a specific version by using the suffix ‘@‘.

$ go get foo@v1.6

16. Test Package Upgrades

Once you have completed upgrading, make sure that all of your old projects are working flawlessly. You can use the following simple command to do this from your terminal.

$ go test all

This command will check whether the applications are working as expected after the package upgrades. You can also test a single project by specifying the import path of the project.

$ go test app/

This will display summarized information on the test results.

17. Find Mistakes in Packages

Go provides a flexible tool for catching unsuspected errors or mistakes in your source file. The go vet command uses heuristics to find suspicious use of constructs, which often lead to actual errors. The below command vets the package that is in the current directory for such errors.

$ go vet

You can also specify the packages using the import path, as shown in the below example.

$ go vet app/

Use the below command to find more information on vet and its available options.

$ go doc cmd/vet

18. Download Modules to Cache

You can download Go Modules to your local cache. This is very useful when working on larger projects and will make app updates easier over time. The command for this looks like below.

$ go mod download [-x] [-json] [modules]

Simply pass the module name, as shown below.

$ go mod download example-project/app

Since Go version 1.11, the downloaded modules are stored in $GOPATH/pkg/mod. The -x options display which commands will be executed by mod download. The -json flag prints a set of JSON objects describing the downloaded module to the terminal output.

19. Maintain Module Dependencies

The go mod tidy command allows us to add missing dependencies or delete unused modules. This go command helps in maintaining module dependencies and keep your applications as lean as possible. Simply run the following simple command to do this.

$ go mod tidy [-v]

Make sure to run this from your project’s root directory. You can check the go.mod file to see which dependencies were added or deleted. The -v flag, if used, causes tidy to display which modules were removed to the standard error.

20. Create Vendored Copy of Dependencies

Go allows developers to create a vendored copy of the module dependencies. This simply resets the main module’s vendor directory and include all the packages that are required to build or test packages that are in the main module.

$ go mod vendor [-v]

The above command makes a vendored copy of the main module’s dependencies. If you use the -v option, it will display the names of the vendored modules and packages to the system’s standard error.

21. Verify Module Dependencies

Programmers can easily verify whether all the dependencies of the current modules have the expected content or not. The “go mod” verify command checks that if any dependencies in the local cache have been modified since download. The command takes the below format.

$ go mod verify

The above command will print ‘all modules verified‘ if the module dependencies are unmodified. Else, it will report which modules have been changed and cause a non-zero exit. This simple tool can help developers determine the integrity of their dependencies.

22. Display Why Packages/Modules are Needed

You can see why certain modules or packages are required in your application. This is useful if you are working with someone else’s code or are trying to figure out what certain things do in a specific project. The “why” command of the mod tool allows us to do this.

$ go mod why [-m] [-vendor] packages...
$ go mod why golang.org/x/text/language golang.org/x/text/encoding

The first one is the general syntax, and the second one is an example. It prints out why the language and encoding packages are required in your application.

23. Disassemble Go Binaries

If you are using Go for systems programming or intensive applications like games, you will need to analyze your executables from time to time. Go provides a set of tools for analyzing binaries. In this example, we will look at the objdump command. It disassembles go executables and works like the Linux objdump command.

$ go tool objdump [-s symregexp] binary

This is supported syntax for objdump. You need to use the go tool utility to use objdump. The below command disassembles a go binary named server.go.

$ go tool objdump ./server

You can limit the disassembly to specific symbols by using the -s option. It will only disassemble the symbols whose name matches symregexp. You will usually want to save the output for detailed inspection.

$ go tool objdump ./server > disassembled-data

24. Display Exported API for Packages

You can easily display the APIs exported by a set of Go packages. You will need to use the api tool of the go command to do this. Take a close look at the below command to see how this works.

$ go tool api

This will print out the APIs for your go packages in the standard output. Redirect the output to a file if you want to save the output of this command.

25. Use Go Assembler

Go comes with an in-built assembler that lets developers create object files from assembler source code. Although you will rarely use assembly with go, having the ability to do so doesn’t hurt. Simply write the assembly code inside your go package. You can then invoke the go assembler, as demonstrated below.

$ go tool asm test.s
$ go tool asm new-test.asm

Usually, systems programmers use assembly to increase the performance of a critical section of code. Even go implements some portion of the math package using assembly, such as the pi computation.

26. Print Build ID of Binaries

The build id of an ELF binary is a unique representation of the build information. Go provides a simple utility for displaying this information directly from your terminal. See the below example to see how this works.

$ go tool buildid server

This will print out the build-id of the binary executable named server. This is created when you generate the binary via go build or other build tools. You can match it with the output of the file command. Run the below command and look for the Go BuildID section.

$ file server

27. Use the CGO Tool

One major feature of Go is its interoperability with C codebases. You can use C codes inside Go sources and vice versa. You can then generate the binary by using the usual go build or install from the root of your package. Alternatively, you can use the cgo tool of the go runtime.

$ go tool cgo [cgo options] [-- compiler options] gofiles...
$ go tool cgo app/ccode.go

Consult the below documentation to see which options are available to cgo.

$ go doc cmd/cgo

28. Use Go Compile

By default, the go build or run command does not create object files. You can use the compile utility of the go command to generate an object file. It will only work when you use go tool, as illustrated in the below example.

$ go tool compile server.go

This command create a binary executable called server as well as an object file named server.o. The compile utility also offers a plethora of useful functionalities. You can check a detailed overview of compile by running the following command.

$ go doc cmd/compile

29. Use Go Dist

The dist utility allows developers to bootstrap, build, and test the go runtime from their terminal. It has the following syntax.

$ go tool dist [command]

Some of the available commands are banner, bootstrap, clean, list, env, and version. You can find a list of all supported commands by running the following.

$ go doc cmd/dist

For example, the following snippet prints the Go installation banner using the dist tool.

$ go tool dist banner

Use the below command to list all supported platforms for Go. It will display a JSON output indicating the OS, Architecture, and CGO support.

$ go tool dist list -json

30. Use the Gofmt Tool

Gofmt is another one of Go’s source formatting utility. It works quite similar to fmt. In fact, when you use go fmt, it calls this under the hood. Gofmt has the following syntax.

$ gofmt [flags] [path ...]

For example, the below command will reformat the source file test.go and print it to the standard output. If you give a pathname instead of a filename, gofmt will try to reformat all .go files inside that directory.

$ gofmt test.go

Contrary to fmt, gofmt does not write back the changes to the original file. You will need to use the -w flag for doing so. Use the following command to get a list of all available flags.

$ go doc cmd/gofmt

The Link utility reads the go archive or object for a package main and creates a binary executable containing all of its dependencies. It is invoked using go tool and has the below syntax.

$ go tool link [flags] main.a

For example, the below command will combine the server.o file with its dependencies and spit out a binary.

$ go tool link server.o

Link supports a large number of flags that allow developers to manage or control the build process. You can find a detailed list of them by running the following command.

$ go doc cmd/link

32. Print Symbol List

You can print the list of symbols contained in an object file, archive, or executable by using the go nm tool. Symbols are simply names of global objects such as methods used by an object file. The syntax of this command is shown below.

$ go tool nm [options] file...
$ go tool nm server.o

The output prints each symbol in a new line. They are separated by three space-separated fields, representing the address, type, and symbol name. You can view the list of symbol types from this page of the Go documentation. The options include size, type, sort, and n.

33. Manage Go Archives

Go allows developers to create, modify, or extract archives. The go tool nm allows us to do such binary operations. It is a basic simulation of the traditional ar tool in Unix. The syntax for this command is shown below.

$ go tool pack op file.a [name...]

The op stands for operations. Pack permits several operations, including creating an archive, adding to the archive, and extracting.

$ go tool pack r server.a server.o

This command appends the file server.o to the archive server.a. You can see the list of all available OP codes by running the following command.

$ go doc cmd/pack

34. Display Profiling data

Go comes with excellent profiling support. If you are developing resource-intensive applications or programming for low-spec machines, profiling will help you increase performance significantly. The pprof utility of the go command allows us to display and interpret profiling data.

$ go tool pprof binary profile
$ go tool pprof ./app cpu.prof

You can work with both CPU and Memory profiles. Moreover, pprof also allows developers to analyze profiling data remotely over the web. Although starting Go programmers may find the API a little bit complicated, we found the performance gain to be worth the learning curve.

35. Display Trace Files

Go provides excellent concurrency support via goroutines. However, we often see developers writing concurrent code that hardly benefits their programs. This happens due to ineffective parallelization, which causes latency, contention, and other performance issues. Thankfully, you can use the go trace utility for visualizing how your goroutines are working.

$ go tool trace trace.out

This command will display the trace file trace.out for a given program, which can be generated in multiple ways. You can use the go test command, runtime/trace.Start, or the net/http/pprof package for creating a trace file for your application. Check out this link to learn more about this.

36. Convert Test Output to JSON

The go command-line utility provides an effective way to convert test output to JSON. You can save this JSON output for later inspection or may use it for further processing. The below command shows us how to do this by using the test2json utility of Golang.

$ go tool test2json [-p pkg] [-t] [./pkg.test -test.v]
$ go tool test2json -p example.go -t example_test.go

The first line contains the syntax for the test2json command, while the second one is a working example. It will display the JSON output directly to the console. You can save this data easily by using a simple redirection.

37. Use the Addr2line Tool

Go provides a minimal simulation of the GNU addr2line tool by means of the go command addr2line. It translates addresses to line numbers in your program. It can be really beneficial to systems programmers and debuggers.

$ go tool addr2line binary

When invoked this way, this command will read hex addresses. For each address, it displays the function name and line number corresponding to that address. You can find more information on this tool by using the following command.

$ go doc cmd/addr2line

38. Display Help Page

The help page of go contains summarized information of standard go commands. It is useful for quickly looking up the usage and syntax of everyday commands. You can invoke the help page by running one of the following simple commands.

$ go help
$ go --help

Moreover, you can also print information for a specific command by using the below syntax.

$ go help <topic>
$ go help install

39. Display Go Documentation

Go provides in-depth documentation for the runtime utilities as well as standard commands. These are extremely useful if you want to master the fundamentals of Golang and learn the best practices. You can invoke the documentation in one of the following ways.

$ man go

This will print out a basic manual for Go. However, go provides individual manuals for each command. You can find out detailed information for a specific command by running the following.

$ man go-<topic>
$ man go-install

To access documentation for various go tools, use the go doc command. The below command displays the documentation for the go link utility.

$ go doc cmd/link

40. Display Version Information

Golang is a relatively new language, and thus it is very common to have differences across various releases. Many features are not available to older go versions at all. So, you need to make sure that your go installation meets the requirements for certain features.

$ go version

The above command will show you which version of the go runtime is installed in your machine. You can use this to make sure your code works the same on the production environment as it does on your development machine.

Golang is enjoying massive popularity due to its robust feature set and performance. Tech giants like Google and Netflix are using Go to build their flagship applications. One of the primary reasons behind Go’s continuing popularity is its standard toolchain. The standard utilities are often more than enough for even the largest of projects. And they are easily accessible by means of simple go commands. In this guide, we have outlined all the major commands needed to increase your go expertise as well as workflow. Hopefully, they will help you become a go master in no time.