Subcomandos de línea de comandos

Introducción

Este laboratorio tiene como objetivo probar tu capacidad para definir y usar subcomandos con su propio conjunto de flags en Golang.

Subcomandos de línea de comandos

Se te pide crear un programa que soporte dos subcomandos, foo y bar, cada uno con su propio conjunto de flags. El subcomando foo debe tener dos flags, enable y name, mientras que el subcomando bar debe tener un flag, level.

• El programa debe usar el paquete flag para definir y analizar los flags.
• El subcomando foo debe tener dos flags, enable y name, ambos de tipo string.
• El subcomando bar debe tener un flag, level, de tipo int.
• El programa debe imprimir un mensaje de error si se proporciona un subcomando no válido.
• El programa debe imprimir los valores de los flags para el subcomando que se invoca.

$ go build command-line-subcommands.go

## Primero invoca el subcomando foo.
$./command-line-subcommands foo -enable -name=joe a1 a2
subcommand 'foo'
enable: true
name: joe
tail: [a1 a2]

## Ahora prueba bar.
$./command-line-subcommands bar -level 8 a1
subcommand 'bar'
level: 8
tail: [a1]

## Pero bar no aceptará los flags de foo.
$./command-line-subcommands bar -enable a1
flag provided but not defined: -enable
Usage of bar:
-level int
level

## A continuación veremos las variables de entorno, otra forma
## común de parametrizar los programas.

A continuación se muestra el código completo:

// Algunas herramientas de línea de comandos, como la herramienta `go` o `git`
// tienen muchos *subcomandos*, cada uno con su propio conjunto de
// flags. Por ejemplo, `go build` y `go get` son dos
// subcomandos diferentes de la herramienta `go`.
// El paquete `flag` nos permite definir fácilmente subcomandos simples
// que tienen sus propios flags.

package main

import (
    "flag"
    "fmt"
    "os"
)

func main() {

    // Declaramos un subcomando usando la función `NewFlagSet`
    // y procedemos a definir nuevos flags específicos
    // para este subcomando.
    fooCmd := flag.NewFlagSet("foo", flag.ExitOnError)
    fooEnable := fooCmd.Bool("enable", false, "enable")
    fooName := fooCmd.String("name", "", "name")

    // Para un subcomando diferente podemos definir diferentes
    // flags admitidos.
    barCmd := flag.NewFlagSet("bar", flag.ExitOnError)
    barLevel := barCmd.Int("level", 0, "level")

    // El subcomando se espera como primer argumento
    // del programa.
    if len(os.Args) < 2 {
        fmt.Println("expected 'foo' or 'bar' subcommands")
        os.Exit(1)
    }

    // Comprobamos qué subcomando se invoca.
    switch os.Args[1] {

    // Para cada subcomando, analizamos sus propios flags y
    // tenemos acceso a los argumentos posicionales finales.
    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)
    }
}

Resumen

En este laboratorio, aprendiste cómo definir y usar subcomandos con su propio conjunto de flags en Golang utilizando el paquete flag. También aprendiste cómo analizar los flags para cada subcomando y acceder a los argumentos posicionales finales.