go flags Unduh - go flags Unduh kode sumber

pergi bendera

Kode sumber lainnya

v1.6.1

Unduh

go-flags: perpustakaan go untuk mengurai argumen baris perintah

Pustaka ini menyediakan fungsionalitas serupa dengan pustaka flag bawaan go, namun menyediakan lebih banyak fungsi dan format yang lebih bagus. Dari dokumentasi:

Bendera paket menyediakan pengurai opsi baris perintah yang ekstensif. Paket flags memiliki fungsionalitas yang mirip dengan paket flag bawaan go, namun menyediakan lebih banyak opsi dan menggunakan refleksi untuk menyediakan cara yang mudah dan ringkas dalam menentukan opsi baris perintah.

Fitur yang didukung:

Pilihan dengan nama pendek (-v)
Opsi dengan nama panjang (--verbose)
Opsi dengan dan tanpa argumen (bool vs tipe lainnya)
Opsi dengan argumen opsional dan nilai default
Beberapa grup opsi masing-masing berisi serangkaian opsi
Hasilkan dan cetak pesan bantuan yang diformat dengan baik
Melewati argumen baris perintah yang tersisa setelah -- (opsional)
Mengabaikan opsi baris perintah yang tidak diketahui (opsional)
Mendukung -I/usr/include -I=/usr/include -I /usr/include spesifikasi argumen opsi
Mendukung beberapa opsi pendek -aux
Mendukung semua tipe go primitif (string, int{8..64}, uint{8..64}, float)
Mendukung opsi yang sama beberapa kali (dapat menyimpan dalam jumlah irisan atau opsi terakhir)
Mendukung peta
Mendukung panggilan balik fungsi
Mendukung namespace untuk grup opsi (bersarang).

Paket flags menggunakan tag bidang struct, refleksi, dan struct untuk memungkinkan pengguna menentukan opsi baris perintah. Hal ini menghasilkan spesifikasi pilihan aplikasi Anda yang sangat sederhana dan ringkas. Misalnya:

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

Ini menentukan satu opsi dengan nama pendek -v dan nama panjang --verbose. Ketika -v atau --verbose ditemukan pada baris perintah, nilai 'true' akan ditambahkan ke bidang Verbose. misalnya ketika menentukan -vvv, nilai Verbose yang dihasilkan adalah {[benar, benar, benar]}.

Contoh:

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