instruction: Explain go by example: command-line subcommands
output: 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.
  Next example:
  Environment Variables
  .
  by
  Mark McGranaghan
  and
  Eli Bendersky
  |
  source
  |
  license