• 设为首页
  • 收藏本站
  • 积分充值
  • VIP赞助
  • 手机版
  • 微博
  • 微信
    微信公众号 添加方式:
    1:搜索微信号(888888
    2:扫描左侧二维码
  • 快捷导航
    福建二哥 门户 查看主题

    Go语言中字符串四种拼接方式的性能对比

    发布者: 福建二哥 | 发布时间: 2025-8-14 13:10| 查看数: 36| 评论数: 0|帖子模式

    简介

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

      1. for
      复制代码
      索引
      1. +=
      复制代码
      的方式
      1. for range +=
      复制代码
      的方式
      1. strings.Join
      复制代码
      的方式
      1. strings.Builder
      复制代码
      的方式

    写一个基准测试文件

    echo_bench_test.go
    1. package main

    2. import (
    3.         "os"
    4.         "strings"
    5.         "testing"
    6. )

    7. func echoAll1() string {
    8.         var s, sep string
    9.         for i := 0; i < len(os.Args); i++ {
    10.                 s += sep + os.Args[i]
    11.                 sep = " "
    12.         }
    13.         return s
    14. }

    15. func echoAll2() string {
    16.         s, sep := "", ""
    17.         for _, arg := range os.Args[:] {
    18.                 s += sep + arg
    19.                 sep = " | "
    20.         }
    21.         return s
    22. }

    23. func echoAll3() string {
    24.         return strings.Join(os.Args[:], " , ")
    25. }

    26. // strings.Builder 是 Go 推荐的高效字符串拼接方式,尤其在循环中拼接时,
    27. // 可以减少内存分配。


    28. func echoAll4() string {
    29.         var builder strings.Builder
    30.         for i, arg := range os.Args[:] {
    31.                 if i > 0 {
    32.                         builder.WriteString(" <> ")
    33.                 }
    34.                 builder.WriteString(arg)
    35.         }
    36.         return builder.String()
    37. }


    38. // ===== Benchmark Functions =====

    39. func BenchmarkEchoAll1(b *testing.B) {
    40.         // 模拟更长参数列表,避免误差过大
    41.         originalArgs := os.Args
    42.         os.Args = make([]string, 100)
    43.         for i := range os.Args {
    44.                 os.Args[i] = "arg"
    45.         }

    46.         b.ResetTimer()
    47.         for i := 0; i < b.N; i++ {
    48.                 _ = echoAll1()
    49.         }
    50.         os.Args = originalArgs // 恢复
    51. }

    52. func BenchmarkEchoAll2(b *testing.B) {
    53.         originalArgs := os.Args
    54.         os.Args = make([]string, 100)
    55.         for i := range os.Args {
    56.                 os.Args[i] = "arg"
    57.         }

    58.         b.ResetTimer()
    59.         for i := 0; i < b.N; i++ {
    60.                 _ = echoAll2()
    61.         }
    62.         os.Args = originalArgs
    63. }

    64. func BenchmarkEchoAll3(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.         b.ResetTimer()
    71.         for i := 0; i < b.N; i++ {
    72.                 _ = echoAll3()
    73.         }
    74.         os.Args = originalArgs
    75. }

    76. func BenchmarkEchoAll4(b *testing.B) {
    77.         originalArgs := os.Args
    78.         os.Args = make([]string, 100)
    79.         for i := range os.Args {
    80.                 os.Args[i] = "arg"
    81.         }

    82.         b.ResetTimer()
    83.         for i := 0; i < b.N; i++ {
    84.                 _ = echoAll4()
    85.         }
    86.         os.Args = originalArgs
    87. }
    复制代码
    运行基准测试
    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),我们会及时删除侵权内容,谢谢合作!

    最新评论

    浏览过的版块

    QQ Archiver 手机版 小黑屋 福建二哥 ( 闽ICP备2022004717号|闽公网安备35052402000345号 )

    Powered by Discuz! X3.5 © 2001-2023

    快速回复 返回顶部 返回列表