在 Go 中解析简单的复选框组

Question

我正在用 Go 解析一个表单，我经常发现需要像这样处理成文本的复选框组：

[ ] Foo
[x] Bar
[ ] Baz
[x] Bat

其中输出应该是一个逗号分隔的列表 "BarText, BatText" 对应于选中的项目，或者 "None" 如果 none 个项目被选中。处理这种情况的好方法是什么？每次都重复这个逻辑似乎是个坏主意。

本着 YAGNI 的精神，没有必要处理未来可能发生的变化，比如翻译成其他语言（实际上这个例子在目前的情况下不太可能有用）。

效率对于此应用程序并不重要。

编辑：代码如下所示 (source)：

func handleCheckboxesForm(w http.ResponseWriter, r *http.Request) {
    b := func(name string) string { // helper function for boolean values in the form
        return r.FormValue(name) == "on"
    }

    text := "Header stuff here"

    mytext := ""
    if b("nfpa-alk") {
        mytext += ", alkaline"
    }
    if b("nfpa-acid") {
        mytext += ", acid"
    }
    if b("nfpa-w") {
        mytext += ", reacts violently with water"
    }
    if b("nfpa-alk") || b("nfpa-acid") || b("nfpa-w") {
        text += mytext[2:] + "\n"
    } else {
        text += "none\n"
    }

    // lots of other checkbox groups here

    // do stuff with text
}

Answer 1

这会将表单值存储到一个数组中。然后，它将数组迭代为一个字符串，并在每个名称的末尾附加“,”。然后，如果它长于 2，它将放在最后一个“，”（2 个字节），否则，打印 "None"

func(w http.ResponseWriter, r *http.Request) {
    r.ParseMultipartForm(0)
    arr := []string{}
    if r.FormValue("Foo") {
        arr = append(arr, "Foo")
    }
    if r.FormValue("Bar") {
        arr = append(arr, "Bar")
    }
    if r.FormValue("Baz") {
        arr = append(arr, "Baz")
    }
    if r.FormValue("Bat") {
        arr = append(arr, "Bat")
    }
    out := ""
    for _, title := range arr {
        out += title +", "
    }
    if len(out) > 2 {
        out := out[0: len(out)-2]   
    } else {
        out = "None"
    }

    fmt.Println(out)
}

如果要迭代，

for k, vs:= range r.Form {   
  for _, v:= range vs{
     fmt.Println(k, v)
  }
}

Answer 2

你的重复代码很多，可以优化掉

您的代码必须至少包含以下 "fragments":

词条名称到词条文本的映射关系，可以存储在map中，如

var mappings = map[string]string {
    "Foo": "Foo text",
    "Bar": "Bar text",
    "Baz": "Baz text",
    "Bat": "Bat text",
    // ... other mappings
}

以及属于一个组的key列表，可以存储在一个slice中，例如
```
var group1 = []string{"Foo", "Bar", "Baz", "Bat"}
```

一旦你定义了这些，你就可以有一个处理组的辅助方法：

func handleGroup(r *http.Request, group []string) (res string) {
    for _, v := range group {
        if r.FormValue(v) == "on" {
            res := ", " + mappings[v]
        }
    }
    if res == "" {
        return "none\n"
    }
    return res[2:] + "\n"
}

就是这样。在此之后你的处理程序可以这么简单：

func checkboxHandler(w http.ResponseWriter, r *http.Request) {
    // Handle group1:
    res1 := handleGroup(r, group1)

    // Handle group2:
    res2 := handleGroup(r, group2)
}

备注：

这不是您的要求，但此解决方案可以非常轻松地处理翻译：每个翻译都可以有自己的 mappings 地图，仅此而已。其他都不需要改变。

性能也不是您关心的问题，但以这种方式附加字符串效率不高。如果性能至少有点问题，您可以通过利用 bytes.Buffer:

在不增加复杂性的情况下改进它

func handleGroup(r *http.Request, group []string) string {
    buf := &bytes.Buffer{}
    for _, v := range group {
        if r.FormValue(v) == "on" {
            buf.WriteString(", ")
            buf.WriteString(mappings[v])
        }
    }
    if buf.Len() == 0 {
        return "none\n"
    }
    buf.WriteString("\n")
    return string(buf.Bytes()[2:])
}

在 Go 中解析简单的复选框组

Parsing simple groups of checkboxes in Go

forms

text

idioms

dry

go