Go by Example: Command-Line Subcommands

Some command-line tools, like the `go` tool or `git` have many subcommands, each with its own set of flags. For example, `go build` and `go get` are two different subcommands of the `go` tool. The `flag` package lets us easily define simple subcommands that have their own flags.
	package main
	import ( "flag" "fmt" "os" )
	func main() {
We declare a subcommand using the `NewFlagSet` function, and proceed to define new flags specific for this subcommand.	fooCmd := flag.NewFlagSet("foo", flag.ExitOnError) fooEnable := fooCmd.Bool("enable", false, "enable") fooName := fooCmd.String("name", "", "name")
For a different subcommand we can define different supported flags.	barCmd := flag.NewFlagSet("bar", flag.ExitOnError) barLevel := barCmd.Int("level", 0, "level")
The subcommand is expected as the first argument to the program.	if len(os.Args) < 2 { fmt.Println("expected 'foo' or 'bar' subcommands") os.Exit(1) }
Check which subcommand is invoked.	switch os.Args[1] {
For every subcommand, we parse its own flags and have access to trailing positional arguments.	case "foo": fooCmd.Parse(os.Args[2:]) fmt.Println("subcommand 'foo'") fmt.Println(" enable:", fooEnable) fmt.Println(" name:", fooName) fmt.Println(" tail:", fooCmd.Args()) case "bar": barCmd.Parse(os.Args[2:]) fmt.Println("subcommand 'bar'") fmt.Println(" level:", *barLevel) fmt.Println(" tail:", barCmd.Args()) default: fmt.Println("expected 'foo' or 'bar' subcommands") os.Exit(1) } }

	$ go build command-line-subcommands.go
First invoke the foo subcommand.	$ ./command-line-subcommands foo -enable -name=joe a1 a2 subcommand 'foo' enable: true name: joe tail: [a1 a2]
Now try bar.	$ ./command-line-subcommands bar -level 8 a1 subcommand 'bar' level: 8 tail: [a1]
But bar won’t accept foo’s flags.	$ ./command-line-subcommands bar -enable a1 flag provided but not defined: -enable Usage of bar: -level int level
Next we’ll look at environment variables, another common way to parameterize programs.