如何在 Golang 中将值列表放入标志中？

Question

Golang 中与以下 python 命令等效的命令是什么？

import argparse
parser = argparse.ArgumentParser(description="something")
parser.add_argument("-getList1",nargs='*',help="get 0 or more values")
parser.add_argument("-getList2",nargs='?',help="get 1 or more values")

我已经看到 flag 包允许在 Golang 中进行参数解析。 但似乎只支持String、Int或Bool。 如何以这种格式将值列表放入标志中：

go run myCode.go -getList1 value1 value2 

Answer 1

您可以定义自己的

flag.Value

并使用

flag.Var()

进行绑定。

示例是这里。

然后你可以传递多个标志，如下所示：

go run your_file.go --list1 value1 --list1 value2

UPD：包括代码片段，以防万一。

package main

import "flag"

type arrayFlags []string

func (i *arrayFlags) String() string {
    return "my string representation"
}

func (i *arrayFlags) Set(value string) error {
    *i = append(*i, value)
    return nil
}

var myFlags arrayFlags

func main() {
    flag.Var(&myFlags, "list1", "Some description for this param.")
    flag.Parse()
}

Answer 2

您至少可以使用

flag.Args()

函数在命令末尾添加参数列表。

package main

import (
    "flag"
    "fmt"
)

var one string

func main() {
    flag.StringVar(&one, "o", "default", "arg one")
    flag.Parse()
    tail := flag.Args()
    fmt.Printf("Tail: %+q\n", tail)
}

my-go-app -o 1 this is the rest

将打印

Tail: ["this" "is" "the" "rest"]

Answer 3

使用 flag.String() 获取所需参数的完整值列表，然后使用 strings.Split() 将其拆分为单独的项目。

Answer 4

如果命令行末尾有一系列整数值，此辅助函数将正确转换它们并将它们放入

int

的切片中：

package main

import (
    "flag"
    "fmt"
    "strconv"
)

func GetIntSlice(i *[]string) []int {
    var arr = *i
    ret := []int{}
    for _, str := range arr {
        one_int, _ := strconv.Atoi(str)
        ret = append(ret, one_int)
    }
    return ret
}

func main() {
    flag.Parse()
    tail := flag.Args()
    fmt.Printf("Tail: %T,  %+v\n", tail, tail)
    intSlice := GetIntSlice(&tail)

    fmt.Printf("intSlice: %T,  %+v\n", intSlice, intSlice)

}

mac:demoProject sx$ go run demo2.go 1 2 3 4
Tail: []string,  [1 2 3 4]
intSlice: []int,  [1 2 3 4]

Answer 5

问题不是问这个。但我来这里寻找如何在标志中使用列表。如果您同意接受以逗号分隔的值，请按以下方法操作。这是得票最多的答案的延伸。这允许参数出现在任何地方。

$ go run . -int-list=1,2,3 -string-list=a,b,c -float-list=1.0
String List: a,b,c
Int List: 1,2,3
Float List: 1

package main

import (
    "flag"
    "fmt"
    "strconv"
    "strings"
)

type StringList []string

func (s StringList) String() string {
    return strings.Join(s, ",")
}

func (s *StringList) Set(value string) error {
    *s = strings.Split(value, ",")
    return nil
}

type IntList []int

func (i IntList) String() string {
    var strValues []string
    for _, val := range i {
        strValues = append(strValues, strconv.Itoa(val))
    }
    return strings.Join(strValues, ",")
}

func (i *IntList) Set(value string) error {
    var intValues []int
    for _, strVal := range strings.Split(value, ",") {
        val, err := strconv.Atoi(strVal)
        if err != nil {
            return fmt.Errorf("invalid integer value: %s", strVal)
        }
        intValues = append(intValues, val)
    }
    *i = intValues
    return nil
}


type FloatList []float64

func (f FloatList) String() string {
    var strValues []string
    for _, val := range f {
        strValues = append(strValues, strconv.FormatFloat(val, 'f', -1, 64))
    }
    return strings.Join(strValues, ",")
}

func (f *FloatList) Set(value string) error {
    var floatValues []float64
    for _, strVal := range strings.Split(value, ",") {
        val, err := strconv.ParseFloat(strVal, 64)
        if err != nil {
            return fmt.Errorf("invalid float value: %s", strVal)
        }
        floatValues = append(floatValues, val)
    }
    *f = floatValues
    return nil
}

var strFlags StringList
var intFlags IntList
var floatFlags FloatList

func main() {
    flag.Var(&strFlags, "string-list", "Comma-separated list of strings.")
    flag.Var(&intFlags, "int-list", "Comma-separated list of integers.")
    flag.Var(&floatFlags, "float-list", "Comma-separated list of floats.")
    flag.Parse()
    fmt.Println("String List:", strFlags)
    fmt.Println("Int List:", intFlags)
    fmt.Println("Float List:", floatFlags)
}