Writing CLI is not difficult in Go and is suitable for projects of various complexity. 1. Start with the main function: process input, execute logic, and output results. You can use os.Args to obtain parameters, which is suitable for simple scripts; 2. Use flag package: for structured input, define parameters and default values, and call flag.Parse() to parse parameters, suitable for medium-sized projects; 3. Organize complex commands. Recommended Cobra framework: supports subcommands, help documents, automatic completion and other functions, with clear structure and easy to expand; 4. Practical techniques include friendly error prompts, support for help subcommands, optional output format, unit testing CLI behavior, and packaging and publishing as binary files globally.
Writing a CLI application is not that difficult, especially in Go. Go's standard library has helped you do a lot of basic work, such as parameter analysis, command line interaction, etc. As long as you have a little understanding of basic Go programming, you can get started quickly.
Basic structure: Start with the main function
The core of CLI application is still main function. You only need to process input parameters, execute logic, and output results in main . Go provides os.Args to get command line parameters, and also supports more advanced packages such as flag or third-party libraries (such as cobra ) to organize complex command structures.
For example, the simplest CLI program might be like this:
package main
import (
"fmt"
"os"
)
func main() {
fmt.Println("Hello, ", os.Args[1])
}Pass the name when running:
go run main.go Alice # Output Hello, Alice
This method is suitable for small scripts or simple tools.
Parameter processing: Use flag package for structured input
When you need multiple options or switch parameters, it is not convenient to operate os.Args directly. At this time, you can consider using flag package, which is specially used in the Go standard library to parse command line parameters.
For example, you want to make a program with -name and -age parameters:
package main
import (
"flag"
"fmt"
)
func main() {
name := flag.String("name", "Guest", "your name")
age := flag.Int("age", 0, "your age")
flag.Parse()
fmt.Printf("Name: %s, Age: %d\n", *name, *age)
}Running effect:
go run main.go -name=Alice -age=30 # Name: Alice, Age: 30
-
flag.Stringandflag.Intdefine parameter names, default values ??and descriptions - Calling
flag.Parse()will actually resolve the parameters - Use pointer
*nameget the actual input content
This writing style is clear and suitable for medium-sized projects.
Organizing complex commands: Recommended cobra library
If your CLI tool functions are increasing, such as subcommands, help documents, automatic completion and other functions, it is recommended to use Cobra . It is a very popular CLI framework and is used by many well-known projects (such as Hugo and Kubernetes).
Installation method:
go get -u github.com/spf13/cobra@latest
To initialize a project structure, you can use cobra-cli :
cobra-cli init
Then you can add subcommands, such as:
cobra-cli add greet
This will generate a cmd/greet.go file, where you can customize the logic. In the end, your CLI may look like this:
myapp greet --name=Alice
The advantage of Cobra is that it is clear structure, easy to expand, and comes with a help system, but it is a little "heavy". If it is a simple script, it may not be necessary.
Some practical tips
- Error prompts should be friendly : If the user enters the wrong parameters, do not panic directly, but give clear prompts.
- Support help subcommand : for example
myapp helpormyapp command --help - Optional output format : for example, support JSON output, which is convenient for other programs to call
- Test CLI behavior : Unit testing can be done by wrapping
os.Argsandos.Stdout - Package and release : Use
go buildto compile it into a binary file, put it under PATH and you can use it globally
Basically that's it. CLI tools do not need to be too complicated, but it is very practical to process parameters clearly, straighten out logic, and add some details to optimize them.
The above is the detailed content of How to build a CLI application in Go. For more information, please follow other related articles on the PHP Chinese website!
Hot AI Tools
Undress AI Tool
Undress images for free
Undresser.AI Undress
AI-powered app for creating realistic nude photos
AI Clothes Remover
Online AI tool for removing clothes from photos.
Clothoff.io
AI clothes remover
Video Face Swap
Swap faces in any video effortlessly with our completely free AI face swap tool!
Hot Article
Hot Tools
Notepad++7.3.1
Easy-to-use and free code editor
SublimeText3 Chinese version
Chinese version, very easy to use
Zend Studio 13.0.1
Powerful PHP integrated development environment
Dreamweaver CS6
Visual web development tools
SublimeText3 Mac version
God-level code editing software (SublimeText3)
Hot Topics
How can you handle JSON encoding and decoding effectively in Go?
Jun 11, 2025 am 12:02 AM
Effective handling of JSON in Go requires attention to structural labels, optional fields and dynamic analysis. Use the struct tag to customize the JSON key name, such as json:"name"; make sure the fields are exported for access by the json package. Use pointers or omitempty tags when processing optional fields to distinguish between unprovided values ??from explicit zeros. When parsing unknown JSON, map[string]interface{} can be used to extract data with type assertions. The default number will be parsed as float64. json.MarshalIndent can be used to beautify the output during debugging, but the production environment should avoid unnecessary formatting. Mastering these techniques can improve the robustness and ability of your code
How can Go programs interact with C code using Cgo? What are the trade-offs?
Jun 10, 2025 am 12:14 AM
Go programs can indeed interact with C code through Cgo, which allows Go to call C functions directly. When using Cgo, just import the pseudo-package "C" and embed C code in the comments above the import line, such as including C function definitions and calling them. In addition, external C library can be linked by specifying link flags such as #cgoLDFLAGS. However, there are many issues to pay attention to when using Cgo: 1. Memory management needs to be processed manually and cannot rely on Go garbage collection; 2. Go types may not match C types, and types such as C.int should be used to ensure consistency; 3. Multiple goroutine calls to non-thread-safe C libraries may cause concurrency problems; 4. There is performance overhead for calling C code, and the number of calls across language boundaries should be reduced. Cgo's lack
How can Go applications be cross-compiled for different operating systems and architectures?
Jun 11, 2025 am 12:12 AM
Yes,Goapplicationscanbecross-compiledfordifferentoperatingsystemsandarchitectures.Todothis,firstsettheGOOSandGOARCHenvironmentvariablestospecifythetargetOSandarchitecture,suchasGOOS=linuxGOARCH=amd64foraLinuxbinaryorGOOS=windowsGOARCH=arm64foraWindow
How does Go handle pointers, and how do they differ from pointers in C/C ?
Jun 10, 2025 am 12:13 AM
Go simplifies the use of pointers and improves security. 1. It does not support pointer arithmetic to prevent memory errors; 2. Automatic garbage collection and management of memory without manual allocation or release; 3. The structure method can seamlessly use values ??or pointers, and the syntax is more concise; 4. Default safe pointers to reduce the risk of hanging pointers and memory leakage. These designs make Go easier to use and safer than C/C, but sacrifice some of the underlying control capabilities.
What are the implications of Go's static linking by default?
Jun 19, 2025 am 01:08 AM
Go compiles the program into a standalone binary by default, the main reason is static linking. 1. Simpler deployment: no additional installation of dependency libraries, can be run directly across Linux distributions; 2. Larger binary size: Including all dependencies causes file size to increase, but can be optimized through building flags or compression tools; 3. Higher predictability and security: avoid risks brought about by changes in external library versions and enhance stability; 4. Limited operation flexibility: cannot hot update of shared libraries, and recompile and deployment are required to fix dependency vulnerabilities. These features make Go suitable for CLI tools, microservices and other scenarios, but trade-offs are needed in environments where storage is restricted or relies on centralized management.
How do I create a buffered channel in Go? (e.g., make(chan int, 10))
Jun 20, 2025 am 01:07 AM
To create a buffer channel in Go, just specify the capacity parameters in the make function. The buffer channel allows the sending operation to temporarily store data when there is no receiver, as long as the specified capacity is not exceeded. For example, ch:=make(chanint,10) creates a buffer channel that can store up to 10 integer values; unlike unbuffered channels, data will not be blocked immediately when sending, but the data will be temporarily stored in the buffer until it is taken away by the receiver; when using it, please note: 1. The capacity setting should be reasonable to avoid memory waste or frequent blocking; 2. The buffer needs to prevent memory problems from being accumulated indefinitely in the buffer; 3. The signal can be passed by the chanstruct{} type to save resources; common scenarios include controlling the number of concurrency, producer-consumer models and differentiation
How can you use Go for system programming tasks?
Jun 19, 2025 am 01:10 AM
Go is ideal for system programming because it combines the performance of compiled languages ??such as C with the ease of use and security of modern languages. 1. In terms of file and directory operations, Go's os package supports creation, deletion, renaming and checking whether files and directories exist. Use os.ReadFile to read the entire file in one line of code, which is suitable for writing backup scripts or log processing tools; 2. In terms of process management, the exec.Command function of the os/exec package can execute external commands, capture output, set environment variables, redirect input and output flows, and control process life cycles, which are suitable for automation tools and deployment scripts; 3. In terms of network and concurrency, the net package supports TCP/UDP programming, DNS query and original sets.
How does Go ensure memory safety without manual memory management like in C?
Jun 19, 2025 am 01:11 AM
Goensuresmemorysafetywithoutmanualmanagementthroughautomaticgarbagecollection,nopointerarithmetic,safeconcurrency,andruntimechecks.First,Go’sgarbagecollectorautomaticallyreclaimsunusedmemory,preventingleaksanddanglingpointers.Second,itdisallowspointe
