go flags Télécharger - go flags Téléchargement du code source

allez les drapeaux

Autre code source

v1.6.1

Télécharger

go-flags : une bibliothèque go pour analyser les arguments de ligne de commande

Cette bibliothèque fournit des fonctionnalités similaires à la bibliothèque de drapeaux intégrée de Go, mais offre beaucoup plus de fonctionnalités et un formatage plus agréable. À partir de la documentation :

Les indicateurs de package fournissent un analyseur complet d’options de ligne de commande. Le package flags a des fonctionnalités similaires au package flag intégré go, mais fournit plus d'options et utilise la réflexion pour fournir un moyen pratique et succinct de spécifier les options de ligne de commande.

Fonctionnalités prises en charge :

Options avec des noms courts (-v)
Options avec des noms longs (--verbose)
Options avec et sans arguments (bool vs autre type)
Options avec arguments facultatifs et valeurs par défaut
Plusieurs groupes d'options contenant chacun un ensemble d'options
Générer et imprimer un message d'aide bien formaté
Passer les arguments de ligne de commande restants après -- (facultatif)
Ignorer les options de ligne de commande inconnues (facultatif)
Prend en charge -I/usr/include -I=/usr/include -I /usr/include spécification d'argument d'option
Prend en charge plusieurs options courtes -aux
Prend en charge tous les types go primitifs (string, int{8..64}, uint{8..64}, float)
Prend en charge la même option plusieurs fois (peut stocker dans une tranche ou le dernier nombre d'options)
Prend en charge les cartes
Prend en charge les rappels de fonctions
Prend en charge les espaces de noms pour les groupes d'options (imbriqués)

Le package flags utilise des balises de champ structs, de réflexion et de structure pour permettre aux utilisateurs de spécifier des options de ligne de commande. Il en résulte une spécification très simple et concise de vos options d'application. Par exemple:

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

Ceci spécifie une option avec un nom court -v et un nom long --verbose. Lorsque -v ou --verbose est trouvé sur la ligne de commande, une valeur « vraie » sera ajoutée au champ Verbose. Par exemple, en spécifiant -vvv, la valeur résultante de Verbose sera {[true, true, true]}.

Exemple:

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