Guide

Go Go Download

Blog

Docs

TUTORIAL Build CLI Apps with Go and Cobra

/ Creating a CLI in Go Using Cobra
What Are

Creating a CLI in Go
Command
Line
Interfaces?

Creating a
CLI in Go
Using Cobra
Using Cobra
Dive into Go CLI Development - A Hands-on
Error Guide with Cobra
Handling in
Cobra Israel Ulelu (Community)
Building a 2024-05-24
Binary
Executable go

Conclusion
Now that you know the basics of command line interfaces and
their underlying principles, let's look at the process of building one
using the Go programming language and Cobra. Cobra is a simple
and powerful open source library released under the Apache
License 2.0 for creating modern command line applications in Go.
With a broad userbase, including notable projects like Kubernetes,
Cosmos SDK, and GitHub CLI, Cobra is highly regarded for its
extensive capabilities. Among its notable features are intelligent
suggestions, command aliases, and support for nested commands,
making it an ideal choice for crafting sophisticated and user-
friendly CLI tools in the Go ecosystem.

In this tutorial, you'll use the Cobra package to create Zero, a

command line application to perform basic mathematical
operations like addition, subtraction, multiplication, and division.
Prerequisites
To complete this tutorial, you'll need the following:

1. Familiarity with the Go programming language and the Go

package installed on your local machine. The Go
documentation provides steps on how to set up Go on your
device.
2. GoLand (or another editor or IDE with support for Go).

Creating a Go Application
Launch your GoLand IDE and initiate a new Go project. Specify
your desired project name and location on your device:

Create a main.go file within the project directory. This file will act
as the central hub for your project's codebase:
Creating a Command
First, create a folder called cmd in the same directory as your
main.go file and then create a root.go file in the newly created
cmd folder.

The root.go file uses the Cobra package to create the root
command and an accessor function to execute the command.
Paste in the code below:

package cmd

import (
"fmt"
"github.com/spf13/cobra"
"os"
)

var rootCmd = &cobra.Command{

Use: "zero",
Short: "zero is a cli tool for performing basic mathematical
Long: "zero is a cli tool for performing basic mathematical
Run: func(cmd *cobra.Command, args []string) {

},
}

func Execute() {
 if err := rootCmd.Execute(); err != nil {
fmt.Fprintf(os.Stderr, "Oops. An error while executing Z
os.Exit(1)
}
}

Here, cobra.Command is used to define a new command with

several properties:
 

Use holds the text used to invoke usage of the command.

Short represents a short description of the command. This is
shown in the CLI help output.
Long is similar to Short but holds a longer description of the
command.
Run holds the function to be executed on the invocation of
the command.

The Execute() function handles the execution of the root

command and handles possible errors by printing the error
messages to the console.

Having created the root command rootCmd , which is the main

entry point and the root of your command tree, you may encounter
a few errors associated with the cobra package. To address these
issues, simply position your cursor over the import statement for
Cobra and click the bulb icon that appears. Select the Sync
dependencies option to trigger the GoLand IDE to automatically
acquire and set up the Cobra package:

Alternatively, you can execute the following command in your

GoLand terminal to install Cobra:

go get -u github.com/spf13/cobra@latest

The following result should print to your console, showing the

successful installation of the cobra package:
You can now utilize the root command's Execute() function in
your main.go file:

package main

import "Zero/cmd"

func main() {
cmd.Execute()
}

At this stage, you can test out your command line application by
running go run main.go --help in your GoLand terminal. You
should get the following help result:
Adding Subcommands
Create a zero.go file in the cmd directory to hold the logic for
your mathematical operations. Save it with the following code:

package cmd

import (
"fmt"
"strconv"
)

func Add(first string, second string) (result string) {

num1, err := strconv.ParseFloat(first, 64)
if err != nil {
fmt.Println("Error: First value is invalid")
return
}
num2, err := strconv.ParseFloat(second, 64)
if err != nil {
fmt.Println("Error: Second value is invalid")
return
}
return fmt.Sprintf("%f", num1+num2)
}

func Subtract(from string, subtract string) (result string) {

num1, err := strconv.ParseFloat(from, 64)
 if err != nil {
fmt.Println("Error: First value is invalid")
return
}
num2, err := strconv.ParseFloat(subtract, 64)
if err != nil {
fmt.Println("Error: Second value is invalid")
return
}
return fmt.Sprintf("%f", num1-num2)
}

Next, you'll create the add and subtract commands to leverage

these functional logics. Start by creating two new files in the cmd
directory: add.go to hold the command for the addition operation
and subtract.go to hold the command for subtraction.

First, for the addition operation, the add.go file should contain the
following lines of code:
 

package cmd

import (
"fmt"
"github.com/spf13/cobra"
)

var addCmd = &cobra.Command{

 Use: "add",
Aliases: []string{"addition"},
Short: "Add 2 numbers",
Long: "Carry out addition operation on 2 numbers",
Args: cobra.ExactArgs(2),
Run: func(cmd *cobra.Command, args []string) {
fmt.Printf("Addition of %s and %s = %s.\n\n", args[0], a
},
}

func init() {
rootCmd.AddCommand(addCmd)
}

 

You'll notice that two new properties are introduced in

cobra.Command that were not used in the rootCmd definition:

Aliases holds an array of alternative texts that can be used to

invoke the command.
Args , short for arguments, defines the constraints for
arguments required by this command. In this case,
cobra.ExactArgs(2) specifies that exactly two arguments are
needed to perform basic mathematical operations. You can
find more argument specifications and constraints in the
Cobra usage documentation.
The add command ( addCmd ) is then added as a subcommand to
the root command in the init() function.

Proceed to implement the subtract command by saving the

following code in the subtract.go file:

package cmd

import (
"fmt"
"github.com/spf13/cobra"
)

var subtractCmd = &cobra.Command{

Use: "subtract",
Aliases: []string{"sub"},
Short: "Subtract a number from another",
Long: "Carry out subtraction operation on 2 integers",
Args: cobra.ExactArgs(2),
Run: func(cmd *cobra.Command, args []string) {
fmt.Printf("Subtraction of %s from %s = %s.\n\n", args[1
},
}

func init() {
rootCmd.AddCommand(subtractCmd)
}

 
The subtract command is also added as a subcommand to
rootCmd in the init() function.

You can now run basic addition and subtraction operations using
Zero, your command line application. Launch your GoLand terminal
and execute the following commands:

go run main.go add 5 2

go run main.go sub 5.4 2
go run main.go sub 5.4 2d

Observe the error printed to the terminal when 2d , which is not a

valid number, is passed as an argument to the command line
application:

You've now created a command line application with both

commands and subcommands.

Adding Command Flags

In the following section, you'll use the multiplication operation to
implement flags in commands so that you can see how flags
modify the behavior of commands. You'll implement a flag to
round up the multiplication result of the numbers provided as
arguments to two decimal places.
First, add the following logic functions for the multiplication
operation to the bottom of the zero.go file:

func Multiply(first string, second string, shouldRoundUp bool) (

num1, err := strconv.ParseFloat(first, 64)
if err != nil {
fmt.Println("Error: First value is not a decimal")
return
}
num2, err := strconv.ParseFloat(second, 64)
if err != nil {
fmt.Println("Error: Second value is not a decimal")
return
}
if shouldRoundUp {
return fmt.Sprintf("%.2f", num1*num2)
}
return fmt.Sprintf("%f", num1*num2)
}

 

Then, create a multiply.go file in the cmd folder. The file will
contain the implementation of the multiplication command and
init() function, as shown below:

package cmd

import (
"fmt"
"github.com/spf13/cobra"
)

var shouldRoundUp bool

var multiplyCmd = &cobra.Command{
Use: "multiply",
Aliases: []string{"mul", "multiple", "multi"},
Short: "Multiply 2 numbers",
Long: "Carry out multiplication operation on 2 numbers",
Args: cobra.ExactArgs(2),
Run: func(cmd *cobra.Command, args []string) {
fmt.Printf("Multiplication of %s and %s = %s.\n\n", args
},
}
 func init() {
multiplyCmd.Flags().BoolVarP(&shouldRoundUp, "round", "r", f
rootCmd.AddCommand(multiplyCmd)
}

In the init() function, multiplyCmd.Flags().BoolVarP adds a

Boolean flag with the name round and the shorthand r to the
multiply command. String flags can also be used as shown in the
 
Cobra documentation.

Next, execute the go run main.go multiply 5.4 2 --round

command with the round flag in your GoLand terminal.
Alternatively, you can also use the flag shorthand by running go
run main.go multiply 5.4 2 -r . You should get the following
result:
  What Are Command Line Error Handling in Cobra 
Interfaces?

Your comment here

Sign In Styling with Markdown is supported

Sort by Recently updated

Privacy & Security Terms of Use Trademarks Legal Genuine tools

Copyright © 2000–2024 JetBrains s.r.o.