如何从Go中的查询参数中提取逗号分隔值？

如何解决如何从Go中的查询参数中提取逗号分隔值？

我正在使用 Gin Web Framework 并且我试图找到一种方法将逗号分隔值列表从查询参数绑定到结构中。以下是我的代码片段：

type QueryParams struct {
    Type            []string `form:"type"`
}


func BulkRead(c *gin.Context) {

    params := QueryParams{
        Type:            []string{},}

    if err := c.ShouldBindQuery(&params); err != nil {
        c.JSON(http.StatusBadRequest,gin.H{"error": "couldn't bind query params"})
        return
    }
    
    c.Status(200)
}

请求：GET /api/v1/car?type=ford,audi

我的期望：["ford","audi"]

我得到了什么："ford,audi"

有没有简单的方法可以做到这一点？或者我是否需要编写一个自定义函数来处理这个问题？

解决方法

要从查询参数中提取逗号分隔值，您可以使用 Split() 包中的 strings 方法。我为您的场景创建了一个简单的程序，如下所示：

package main

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

func main() {

    var cars []string
    qryResult := "ford,audi"
    carBrands := strings.Split(qryResult,",")
    fmt.Println(carBrands)

    for i := 0; i < len(carBrands); i++ {

        cars = append(cars,strconv.Quote(carBrands[i]))
    }

    fmt.Println(cars)

}

输出：

[ford audi]
["ford" "audi"]

,

它可能对您也有帮助。

package main

import (
    "log"
    "net/http"
    "strings"

    "github.com/gin-gonic/gin"
)

type TypeBinding struct {
    name string
}

func NewTypeBinding(name string) *TypeBinding {
    return &TypeBinding{
        name: name,}
}

func (t *TypeBinding) Name() string {
    return t.name
}

func (t *TypeBinding) Bind(r *http.Request,i interface{}) error {
    ttype := r.URL.Query().Get(t.name)

    ii := i.(*QueryParams)

    ii.Type = strings.Split(ttype,")

    return nil
}

type QueryParams struct {
    Type []string `url:"type"`
}

func ggin() {
    router := gin.Default()

    typeBinding := NewTypeBinding("type")
    var opt QueryParams

    router.GET("/",func(c *gin.Context) {
        if err := c.MustBindWith(&opt,typeBinding); err != nil {
            c.JSON(http.StatusBadRequest,gin.H{"error": "couldn't bind query params"})
            return
        }

        log.Printf("type: %v",opt.Type)
        c.String(http.StatusOK,"type: %s",opt.Type)
    })
    router.Run(":8080")
}

,

Gin 没有办法为您做到这一点。最简单的解决方案是获取查询参数并自行拆分。这实际上是两行代码：

NOT EXISTS

---

如果您可以选择更改请求的方式，请将其更改为：

SELECT t1.* FROM tablename t1 WHERE t1.Name = 'z' AND NOT EXISTS ( SELECT 1 FROM tablename t2 WHERE t2.ID = t1.ID AND t2.Name IN ('x','y') AND t2.Value IS NOT NULL ) （重复查询键）

或对逗号进行 URL 编码：

func MyHandler(c *gin.Context) { ss := strings.Split(c.Query("type"),") fmt.Println(ss) // [ford audi] qp := QueryParams{ Type: ss,} } (GET /api/v1/car?type=ford&type=audi -> GET /api/v1/car?type=ford%20audi)

然后 context.GetQueryArray 会按您的预期工作：

,

---

当然，实现您自己的 %20 是一种选择，适用于您不仅拥有该查询参数并且想要将绑定逻辑封装到一个地方的情况，但我觉得这对于您的用例来说太过分了：>

func MyHandler(c *gin.Context) {
    cars,_ := c.GetQueryArray("type")
    fmt.Println(cars) // [ford audi]
}

,

可能没有这种方式。 通常我这样做：

type QueryParams struct {
    Type string `form:"type"`
}

func (q *QueryParams) Types() []string {
    return strings.Split(q.Type,")
}

func BulkRead(c *gin.Context) {
    params := new(QueryParams)

    if err := c.ShouldBindQuery(&params); err != nil {
        c.JSON(http.StatusBadRequest,gin.H{"error": "couldn't bind query params"})
        return
    }
    c.JSONP(200,map[string]interface{}{
        "types": params.Types(),})
}