Descargar go flags - Descargar código fuente go flags

ir banderas

Otro código fuente

v1.6.1

Descargar

go-flags: una biblioteca go para analizar argumentos de línea de comando

Esta biblioteca proporciona una funcionalidad similar a la biblioteca de indicadores incorporada de go, pero proporciona mucha más funcionalidad y un formato más agradable. De la documentación:

Package flags proporciona un extenso analizador de opciones de línea de comando. El paquete flags es similar en funcionalidad al paquete de banderas incorporado go, pero proporciona más opciones y utiliza la reflexión para proporcionar una manera conveniente y concisa de especificar opciones de línea de comando.

Funciones compatibles:

Opciones con nombres cortos (-v)
Opciones con nombres largos (--verbose)
Opciones con y sin argumentos (bool vs otro tipo)
Opciones con argumentos opcionales y valores predeterminados
Múltiples grupos de opciones, cada uno de los cuales contiene un conjunto de opciones.
Genere e imprima un mensaje de ayuda bien formateado
Pasar los argumentos restantes de la línea de comando después de -- (opcional)
Ignorar opciones de línea de comando desconocidas (opcional)
Admite -I/usr/include -I=/usr/include -I /usr/include especificación del argumento de la opción
Admite múltiples opciones cortas -aux
Admite todos los tipos primitivos de go (cadena, int{8..64}, uint{8..64}, float)
Admite la misma opción varias veces (puede almacenarse en porciones o en los recuentos de las últimas opciones)
Soporta mapas
Admite devoluciones de llamadas de funciones
Admite espacios de nombres para grupos de opciones (anidados)

El paquete flags utiliza etiquetas de campos de estructura, reflexión y estructura para permitir a los usuarios especificar opciones de línea de comando. Esto da como resultado una especificación muy simple y concisa de las opciones de su aplicación. Por ejemplo:

 type Options struct {
	Verbose [] bool `short:"v" long:"verbose" description:"Show verbose debug information"`
}

Esto especifica una opción con un nombre corto -v y un nombre largo --verbose. Cuando se encuentra -v o --verbose en la línea de comando, se agregará un valor "verdadero" al campo Detallado. por ejemplo, al especificar -vvv, el valor resultante de Verbose será {[verdadero, verdadero, verdadero]}.

Ejemplo:

to call a number. // Note that this works just on OS X (and probably only with // Skype) but it shows the idea. opts.Call = func(num string) { cmd := exec.Command("open", "callto:"+num) cmd.Start() cmd.Process.Release() } // Make some fake arguments to parse. args := []string{ "-vv", "--offset=5", "-n", "Me", "--animal", "dog", // anything other than "cat" or "dog" will raise an error "-p", "3", "-s", "hello", "-s", "world", "--ptrslice", "hello", "--ptrslice", "world", "--intmap", "a:1", "--intmap", "b:5", "arg1", "arg2", "arg3", } // Parse flags from `args'. Note that here we use flags.ParseArgs for // the sake of making a working example. Normally, you would simply use // flags.Parse(&opts) which uses os.Args args, err := flags.ParseArgs(&opts, args) if err != nil { panic(err) } fmt.Printf("Verbosity: %vn", opts.Verbose) fmt.Printf("Offset: %dn", opts.Offset) fmt.Printf("Name: %sn", opts.Name) fmt.Printf("Animal: %sn", opts.Animal) fmt.Printf("Ptr: %dn", *opts.Ptr) fmt.Printf("StringSlice: %vn", opts.StringSlice) fmt.Printf("PtrSlice: [%v %v]n", *opts.PtrSlice[0], *opts.PtrSlice[1]) fmt.Printf("IntMap: [a:%v b:%v]n", opts.IntMap["a"], opts.IntMap["b"]) fmt.Printf("Remaining args: %sn", strings.Join(args, " ")) // Output: Verbosity: [true true] // Offset: 5 // Name: Me // Ptr: 3 // StringSlice: [hello world] // PtrSlice: [hello world] // IntMap: [a:1 b:5] // Remaining args: arg1 arg2 arg3">

 var opts struct {
	// Slice of bool will append 'true' each time the option
	// is encountered (can be set multiple times, like -vvv)
	Verbose [] bool `short:"v" long:"verbose" description:"Show verbose debug information"`

	// Example of automatic marshalling to desired type (uint)
	Offset uint `long:"offset" description:"Offset"`

	// Example of a callback, called each time the option is found.
	Call func ( string ) `short:"c" description:"Call phone number"`

	// Example of a required flag
	Name string `short:"n" long:"name" description:"A name" required:"true"`

	// Example of a flag restricted to a pre-defined set of strings
	Animal string `long:"animal" choice:"cat" choice:"dog"`

	// Example of a value name
	File string `short:"f" long:"file" description:"A file" value-name:"FILE"`

	// Example of a pointer
	Ptr * int `short:"p" description:"A pointer to an integer"`

	// Example of a slice of strings
	StringSlice [] string `short:"s" description:"A slice of strings"`

	// Example of a slice of pointers
	PtrSlice [] * string `long:"ptrslice" description:"A slice of pointers to string"`

	// Example of a map
	IntMap map [ string ] int `long:"intmap" description:"A map from string to int"`

	// Example of env variable
	Thresholds  [] int     `long:"thresholds" default:"1" default:"2" env:"THRESHOLD_VALUES"  env-delim:","`
}

// Callback which will invoke callto: to call a number.
// Note that this works just on OS X (and probably only with
// Skype) but it shows the idea.
opts . Call = func ( num string ) {
	cmd := exec . Command ( "open" , "callto:" + num )
	cmd . Start ()
	cmd . Process . Release ()
}

// Make some fake arguments to parse.
args := [] string {
	"-vv" ,
	"--offset=5" ,
	"-n" , "Me" ,
	"--animal" , "dog" , // anything other than "cat" or "dog" will raise an error
	"-p" , "3" ,
	"-s" , "hello" ,
	"-s" , "world" ,
	"--ptrslice" , "hello" ,
	"--ptrslice" , "world" ,
	"--intmap" , "a:1" ,
	"--intmap" , "b:5" ,
	"arg1" ,
	"arg2" ,
	"arg3" ,
}

// Parse flags from `args'. Note that here we use flags.ParseArgs for
// the sake of making a working example. Normally, you would simply use
// flags.Parse(&opts) which uses os.Args
args , err := flags . ParseArgs ( & opts , args )

if err != nil {
	panic ( err )
}

fmt . Printf ( "Verbosity: %v n " , opts . Verbose )
fmt . Printf ( "Offset: %d n " , opts . Offset )
fmt . Printf ( "Name: %s n " , opts . Name )
fmt . Printf ( "Animal: %s n " , opts . Animal )
fmt . Printf ( "Ptr: %d n " , * opts . Ptr )
fmt . Printf ( "StringSlice: %v n " , opts . StringSlice )
fmt . Printf ( "PtrSlice: [%v %v] n " , * opts . PtrSlice [ 0 ], * opts . PtrSlice [ 1 ])
fmt . Printf ( "IntMap: [a:%v b:%v] n " , opts . IntMap [ "a" ], opts . IntMap [ "b" ])
fmt . Printf ( "Remaining args: %s n " , strings . Join ( args , " " ))

// Output: Verbosity: [true true]
// Offset: 5
// Name: Me
// Ptr: 3
// StringSlice: [hello world]
// PtrSlice: [hello world]
// IntMap: [a:1 b:5]
// Remaining args: arg1 arg2 arg3