Gain insights into writing professional command-line programs in Go. Delve into structuring Go programs, writing idiomatic code, testing effectively, and impressing users and managers.

write professional command  - line programs in Go.png

data.tar.gz

Go run main.go

Run main.sh

Run go test

Run go test2

GoLive

GoLiveTesting

Multi-git-Custom

Pre+main-v0.2

Main_to_cmd

Run go test-Coverage

Ginkgo

Ginkgo-BDD

Ginkgo-e2e

Cobra

Cobra-NoInstall

Cobra-NoInstall-FullApp

Final_Cobra_Multi-git

Viper

Viper-etcd

Viper-Cobra

SelfUpdating

Make

Special build

Embedding_Data

Go run main.go-Simple

In this course you will learn why Go is an awesome language for writing command-line programs. You will learn how to structure your Go programs, how to write idiomatic Go code, how to test your programs and how to amaze your users, peers and managers. 

The focus is on command-line programs in order to keep the course down to earth, but most of the principles and best practices you will learn apply to any Go program.

Write Professional Command-line Programs in Go

## Defining the root command

Our starting point is an application with a package for doing calculations. Here is the directory structure:

```
$ tree
.
├── go.mod
├── go.sum
└── pkg
    └── calc
        └── calc.go
```

As you can see, there is just the pkg directory with the `calc` package inside it. There isn't even a main package yet.

The first step is to define a Cobra root command. This command is always executed when the program is invoked, and it may delegate the actual work to subcommands. We will create our commands in a top-level directory called `cmd`. The root command will be in its own file called `cmd/root.go`. 

Let's break it down piece by piece. First, we declare the package as `cmd` and add some imports, most notably Cobra itself:

```
package cmd

import (
	"fmt"
	"os"

	"github.com/spf13/cobra"
)
```

Then, we initiate the command itself as a `cobra.Command`. We provide several arguments to describe the command. We can also declare a Run function that will execute when no sub-commands are provided. However, in this case we leave it without comments out, so subcommands are required.

```
var rootCmd = &cobra.Command{
	Use:   "calc",
	Short: "Calculate arithmetic expressions",
	Long: `Calculate arithmetic expressions.
           
           It can add integers and subtract integers`,
	// Uncomment the following line if you want the root command
	// to perform some action
	//	Run: func(cmd *cobra.Command, args []string) { },
}
```

The reason for this decision is that there is no useful calculation we can do without additional `add` or `subtract` subcommands. 

> You can explore and run the `calc` app in the application below. Please set the `GO111Module` to `on` to run the following applications.

# Defining the root command

Our starting point is an application with a package for doing calculations. Here is the directory structure:

```
$ tree
.
├── go.mod
├── go.sum
└── pkg
    └── calc
        └── calc.go
```

As you can see, there is just the pkg directory with the `calc` package inside it. There isn't even a main package yet.

The first step is to define a Cobra root command. This command is always executed when the program is invoked, and it may delegate the actual work to subcommands. We will create our commands in a top-level directory called `cmd`. The root command will be in its own file called `cmd/root.go`. 

Let's break it down piece by piece. First, we declare the package as `cmd` and add some imports, most notably Cobra itself:

```
package cmd

import (
	"fmt"
	"os"

	"github.com/spf13/cobra"
)
```

Then, we initiate the command itself as a `cobra.Command`. We provide several arguments to describe the command. We can also declare a Run function that will execute when no sub-commands are provided. However, in this case we leave it without comments out, so subcommands are required.

```
var rootCmd = &cobra.Command{
	Use:   "calc",
	Short: "Calculate arithmetic expressions",
	Long: `Calculate arithmetic expressions.
           
           It can add integers and subtract integers`,
	// Uncomment the following line if you want the root command
	// to perform some action
	//	Run: func(cmd *cobra.Command, args []string) { },
}
```

The reason for this decision is that there is no useful calculation we can do without additional `add` or `subtract` subcommands. 

> You can explore and run the `calc` app in the application below. Please set the `GO111Module` to `on` to run the following applications.

In this lesson, you'll learn how to get started with Cobra as a library and define the root command for a simple calculator application.

Working with Cobra - The Root Command

Overview

Restructuring multi-git

Testing 1,2,3...

Adding Smart Command-Line Parsing

Adding Advanced Configuration

Adding Bells and Whistles

Summary

Working with Cobra - The Root Command

Defining the root command