¿Cómo acceder a los argumentos de línea de comando pasados ​​a un programa Go?

Question

¿Cómo accedo a los argumentos de línea de comandos en Ir? No se pasan como argumentos al main.

Un programa completo, posiblemente creado por la vinculación de varios paquetes, debe tener un paquete llamado principal, con una función

func main() { ... } 

definido. La función main.main() no toma argumentos y no devuelve ningún valor.

Answer 1

Puede acceder a los argumentos de la línea de comandos utilizando la variable os.Args. Por ejemplo,

package main 

import (
    "fmt" 
    "os" 
) 

func main() { 
    fmt.Println(len(os.Args), os.Args) 
} 

También puede utilizar el flag package, que implementa la línea de comandos de la bandera de análisis.

Answer 2

Los argumentos de la línea de comando se pueden encontrar en os.Args. En la mayoría de los casos, aunque el paquete flag es mejor porque analiza el argumento por usted.

Answer 3

La respuesta de Peter es exactamente lo que necesita si solo quiere una lista de argumentos.

Sin embargo, si está buscando una funcionalidad similar a la presente en UNIX, entonces podría usar el go implementation de docopt. Puedes probarlo here.

docopt devolverá JSON que luego podrá procesar al contenido de su corazón.

Answer 4

La bandera es un buen paquete para eso.

// [_Command-line flags_](http://en.wikipedia.org/wiki/Command-line_interface#Command-line_option) 
// are a common way to specify options for command-line 
// programs. For example, in `wc -l` the `-l` is a 
// command-line flag. 

package main 

// Go provides a `flag` package supporting basic 
// command-line flag parsing. We'll use this package to 
// implement our example command-line program. 
import "flag" 
import "fmt" 

func main() { 

    // Basic flag declarations are available for string, 
    // integer, and boolean options. Here we declare a 
    // string flag `word` with a default value `"foo"` 
    // and a short description. This `flag.String` function 
    // returns a string pointer (not a string value); 
    // we'll see how to use this pointer below. 
    wordPtr := flag.String("word", "foo", "a string") 

    // This declares `numb` and `fork` flags, using a 
    // similar approach to the `word` flag. 
    numbPtr := flag.Int("numb", 42, "an int") 
    boolPtr := flag.Bool("fork", false, "a bool") 

    // It's also possible to declare an option that uses an 
    // existing var declared elsewhere in the program. 
    // Note that we need to pass in a pointer to the flag 
    // declaration function. 
    var svar string 
    flag.StringVar(&svar, "svar", "bar", "a string var") 

    // Once all flags are declared, call `flag.Parse()` 
    // to execute the command-line parsing. 
    flag.Parse() 

    // Here we'll just dump out the parsed options and 
    // any trailing positional arguments. Note that we 
    // need to dereference the pointers with e.g. `*wordPtr` 
    // to get the actual option values. 
    fmt.Println("word:", *wordPtr) 
    fmt.Println("numb:", *numbPtr) 
    fmt.Println("fork:", *boolPtr) 
    fmt.Println("svar:", svar) 
    fmt.Println("tail:", flag.Args()) 
}