由于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 时传递足够大的字节片，我们仍然可以将分配减少到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
我们也可以创建文本模板，使用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() 函数）还将字节从字符串复制到字节切片。”
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() 快 3.6 倍，buildBuffer2()（具有预先计算的大小）大约比 buildBuffer2() 快 30% buildBuffer() 因为它不需要重新分配（和复制）内部缓冲区。
一些令人惊讶的事实：buildJoin() 非常快，甚至比 buildBuffer2() 快 2.4 倍（因为只使用了 []byte 和 copy()）。另一方面，buildTemplate() 被证明相当慢：7 倍 比 buildOriginal() 慢。这样做的主要原因是因为它在后台使用（必须使用）反射。