简介

使用完整的基准测试代码文件，可以直接运行来比较四种字符串拼接方法的性能。

• 1. for

  复制代码
  索引
  1. +=

  复制代码
  的方式
  
• 1. for range +=

  复制代码
  的方式
  
• 1. strings.Join

  复制代码
  的方式
  
• 1. strings.Builder

  复制代码
  的方式
  

写一个基准测试文件

echo_bench_test.go

1. package main
   
2. 
   
3. import (
   
4.         "os"
   
5.         "strings"
   
6.         "testing"
   
7. )
   
8. 
   
9. func echoAll1() string {
   
10.         var s, sep string
    
11.         for i := 0; i < len(os.Args); i++ {
    
12.                 s += sep + os.Args[i]
    
13.                 sep = " "
    
14.         }
    
15.         return s
    
16. }
    
17. 
    
18. func echoAll2() string {
    
19.         s, sep := "", ""
    
20.         for _, arg := range os.Args[:] {
    
21.                 s += sep + arg
    
22.                 sep = " | "
    
23.         }
    
24.         return s
    
25. }
    
26. 
    
27. func echoAll3() string {
    
28.         return strings.Join(os.Args[:], " , ")
    
29. }
    
30. 
    
31. // strings.Builder 是 Go 推荐的高效字符串拼接方式，尤其在循环中拼接时，
    
32. // 可以减少内存分配。
    
33. 
    
34. 
    
35. func echoAll4() string {
    
36.         var builder strings.Builder
    
37.         for i, arg := range os.Args[:] {
    
38.                 if i > 0 {
    
39.                         builder.WriteString(" <> ")
    
40.                 }
    
41.                 builder.WriteString(arg)
    
42.         }
    
43.         return builder.String()
    
44. }
    
45. 
    
46. 
    
47. // ===== Benchmark Functions =====
    
48. 
    
49. func BenchmarkEchoAll1(b *testing.B) {
    
50.         // 模拟更长参数列表，避免误差过大
    
51.         originalArgs := os.Args
    
52.         os.Args = make([]string, 100)
    
53.         for i := range os.Args {
    
54.                 os.Args[i] = "arg"
    
55.         }
    
56. 
    
57.         b.ResetTimer()
    
58.         for i := 0; i < b.N; i++ {
    
59.                 _ = echoAll1()
    
60.         }
    
61.         os.Args = originalArgs // 恢复
    
62. }
    
63. 
    
64. func BenchmarkEchoAll2(b *testing.B) {
    
65.         originalArgs := os.Args
    
66.         os.Args = make([]string, 100)
    
67.         for i := range os.Args {
    
68.                 os.Args[i] = "arg"
    
69.         }
    
70. 
    
71.         b.ResetTimer()
    
72.         for i := 0; i < b.N; i++ {
    
73.                 _ = echoAll2()
    
74.         }
    
75.         os.Args = originalArgs
    
76. }
    
77. 
    
78. func BenchmarkEchoAll3(b *testing.B) {
    
79.         originalArgs := os.Args
    
80.         os.Args = make([]string, 100)
    
81.         for i := range os.Args {
    
82.                 os.Args[i] = "arg"
    
83.         }
    
84. 
    
85.         b.ResetTimer()
    
86.         for i := 0; i < b.N; i++ {
    
87.                 _ = echoAll3()
    
88.         }
    
89.         os.Args = originalArgs
    
90. }
    
91. 
    
92. func BenchmarkEchoAll4(b *testing.B) {
    
93.         originalArgs := os.Args
    
94.         os.Args = make([]string, 100)
    
95.         for i := range os.Args {
    
96.                 os.Args[i] = "arg"
    
97.         }
    
98. 
    
99.         b.ResetTimer()
    
100.         for i := 0; i < b.N; i++ {
     
101.                 _ = echoAll4()
     
102.         }
     
103.         os.Args = originalArgs
     
104. }

复制代码

运行基准测试

1. go test -bench=. -benchmem

复制代码

示例输出结果（不同机器会略有不同）：

1. goos: darwingoarch: amd64pkg: exampleBenchmarkEchoAll1-8     500000     3500 ns/op     120 B/op     5 allocs/opBenchmarkEchoAll2-8     700000     2400 ns/op     104 B/op     4 allocs/opBenchmarkEchoAll3-8    1000000     1600 ns/op      80 B/op     2 allocs/opBenchmarkEchoAll4-8    2000000      800 ns/op      32 B/op     1 allocs/opPASSok      example    3.456s

复制代码

每一行含义：
字段含义BenchmarkEchoAll1测试函数名-8使用的 CPU 线程数（8 核）500000b.N 的值，代表该函数跑了 50 万次3500 ns/op每次调用耗时 3500 纳秒120 B/op每次操作分配的字节数（字节越少越好）5 allocs/op每次操作的内存分配次数（次数越少越好）

1. Go

复制代码

的基准测试自动决定运行次数（

1. b.N

复制代码

），直到结果足够稳定。
方法ns/opB/opallocs/op说明EchoAll13500 ns120 B5+= 每次创建新字符串，开销大EchoAll22400 ns104 B4range + +=，仍然多次内存分配EchoAll31600 ns80 B2Join 比较高效EchoAll4800 ns32 B1strings.Builder 最优到此这篇关于Go语言中字符串四种拼接方式的性能对比的文章就介绍到这了,更多相关Go字符串拼接内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

来源：互联网
免责声明：如果侵犯了您的权益，请联系站长（1277306191@qq.com），我们会及时删除侵权内容，谢谢合作！