在这里，我试图从包含字符串的 slice 中为我的 API 创建一个查询字符串。

即。 where={"node_name":"node1","node_name":"node_2"}

import (
   "fmt"
   "strings"
)

func main() {
    nodes := []string{"node1", "node2"}
    var query string
    for _, n := range nodes {
        query += fmt.Sprintf("\"node_name\":\"%s\",", n)
    }
    query = strings.TrimRight(query, ",")
    final := fmt.Sprintf("where={%s}", query)
    fmt.Println(final)
}

这里是 goplayground链接。

获得结果的最佳方式是什么？

最佳答案

由于 string 连接，您的解决方案使用了太多分配。

我们将创建一些替代的、更快和/或更优雅的解决方案。请注意，以下解决方案不会检查节点值是否包含引号 " 字符。如果包含，则必须以某种方式对这些字符进行转义(否则结果将是无效的查询字符串)。

完整的可运行代码可以在 Go Playground 上找到.完整的测试/基准测试代码也可以在 Go Playground 上找到。 ，但它不可运行，将两者都保存到您的 Go 工作区(例如 $GOPATH/src/query/query.go 和 $GOPATH/src/query/query_test.go ) 并使用 go test -bench . 运行它。

另请务必查看此相关问题:How to efficiently concatenate strings in Go?

备选方案

创世纪

您的逻辑可以通过以下函数捕获:

func buildOriginal(nodes []string) string {
    var query string
    for _, n := range nodes {
        query += fmt.Sprintf("\"node_name\":\"%s\",", n)
    }
    query = strings.TrimRight(query, ",")
    return fmt.Sprintf("where={%s}", query)
}

使用bytes.Buffer

更好的方法是使用单个缓冲区，例如bytes.Buffer ，在其中构建查询，并在末尾将其转换为 string:

func buildBuffer(nodes []string) string {
    buf := &bytes.Buffer{}
    buf.WriteString("where={")
    for i, v := range nodes {
        if i > 0 {
            buf.WriteByte(',')
        }
        buf.WriteString(`"node_name":"`)
        buf.WriteString(v)
        buf.WriteByte('"')
    }
    buf.WriteByte('}')
    return buf.String()
}

使用它:

nodes := []string{"node1", "node2"}
fmt.Println(buildBuffer(nodes))

输出:

where={"node_name":"node1","node_name":"node2"}

bytes.Buffer 改进

bytes.Buffer 仍会进行一些重新分配，尽管比您的原始解决方案要少得多。

但是，如果我们在使用 bytes.NewBuffer() 创建 bytes.Buffer 时传递足够大的 byte slice ，我们仍然可以将分配减少到 1 .我们可以先计算出所需的大小:

func buildBuffer2(nodes []string) string {
    size := 8 + len(nodes)*15
    for _, v := range nodes {
        size += len(v)
    }
    buf := bytes.NewBuffer(make([]byte, 0, size))
    buf.WriteString("where={")
    for i, v := range nodes {
        if i > 0 {
            buf.WriteByte(',')
        }
        buf.WriteString(`"node_name":"`)
        buf.WriteString(v)
        buf.WriteByte('"')
    }
    buf.WriteByte('}')
    return buf.String()
}

请注意，在 size 计算中，8 是字符串的大小，where={} 而 15 是字符串 "node_name":"", 的大小。

使用文本/模板

我们还可以创建一个文本模板，并使用 text/template包来执行它，高效地生成结果:

var t = template.Must(template.New("").Parse(templ))

func buildTemplate(nodes []string) string {
    size := 8 + len(nodes)*15
    for _, v := range nodes {
        size += len(v)
    }
    buf := bytes.NewBuffer(make([]byte, 0, size))
    if err := t.Execute(buf, nodes); err != nil {
        log.Fatal(err) // Handle error
    }
    return buf.String()
}

const templ = `where={
{{- range $idx, $n := . -}}
    {{if ne $idx 0}},{{end}}"node_name":"{{$n}}"
{{- end -}}
}`

使用strings.Join()

这个解决方案很有趣，因为它很简单。我们可以使用 strings.Join()使用静态文本 ","node_name":" 连接节点，应用适当的前缀和后缀。

需要注意的重要事项:strings.Join() 使用内置 copy()使用单个预分配的 []byte 缓冲区运行，所以速度非常快! “作为一种特殊情况，它(copy() 函数)还将字节从字符串复制到 byte slice 。”

func buildJoin(nodes []string) string {
    if len(nodes) == 0 {
        return "where={}"
    }
    return `where={"node_name":"` + strings.Join(nodes, `","node_name":"`) + `"}`
}

基准测试结果

我们将使用以下 nodes 值进行基准测试:

var nodes = []string{"n1", "node2", "nodethree", "fourthNode",
    "n1", "node2", "nodethree", "fourthNode",
    "n1", "node2", "nodethree", "fourthNode",
    "n1", "node2", "nodethree", "fourthNode",
    "n1", "node2", "nodethree", "fourthNode",
}

基准测试代码如下所示:

func BenchmarkOriginal(b *testing.B) {
    for i := 0; i < b.N; i++ {
        buildOriginal(nodes)
    }
}

func BenchmarkBuffer(b *testing.B) {
    for i := 0; i < b.N; i++ {
        buildBuffer(nodes)
    }
}

// ... All the other benchmarking functions look the same

现在结果:

BenchmarkOriginal-4               200000             10572 ns/op
BenchmarkBuffer-4                 500000              2914 ns/op
BenchmarkBuffer2-4               1000000              2024 ns/op
BenchmarkBufferTemplate-4          30000             77634 ns/op
BenchmarkJoin-4                  2000000               830 ns/op

一些不足为奇的事实:buildBuffer() 比 buildOriginal() 和 buildBuffer2() 快 3.6 倍>(具有预先计算的大小)比 buildBuffer() 快大约 30%，因为它不需要重新分配(和复制)内部缓冲区。

一些令人惊讶的事实:buildJoin() 非常快，甚至比 buildBuffer2() 快 2.4 倍(因为只使用了一个 []byte 和 copy())。另一方面，buildTemplate() 被证明相当慢:比 buildOriginal() 慢 7 倍。这样做的主要原因是因为它在底层使用(必须使用)反射。

关于string - 使用 slice 值的 Golang 字符串格式，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/41457273/