Go语言高性能字符串拼接

最新推荐文章于 2023-01-17 15:14:29 发布
最新推荐文章于 2023-01-17 15:14:29 发布
阅读量252 收藏
点赞数
分类专栏： Go语言 服务器编程 高性能 文章标签： Go 字符串 高性能 Go编程 依赖库
原文链接：https://www.ilove-map.com/article/detail/5d7eece444e69c15d9034f87
版权

Go语言高性能字符串拼接

1. 使用strings.Builder

strings.Builder 使用 Write 方法来高效的构造字符串. 它使用内存最小,它使用零值,它不拷贝零值.
注意:不要拷贝strings.Builder的值,如果你要使用strings.Builder值请使用pointer

package main

import (
    "strings"
    "fmt"
)

func main() {
    var str strings.Builder

    for i := 0; i < 1000; i++ {
        str.WriteString("a")
    }

    fmt.Println(str.String())
}

2.使用bytes.Buffer

package main

import (
    "bytes"
    "fmt"
)

func main() {
    var buffer bytes.Buffer

    for i := 0; i < 1000; i++ {
        buffer.WriteString("a")
    }

    fmt.Println(buffer.String())
}

3.使用go语言内置函数copy

package main

import (
    "bytes"
    "fmt"
)

func main() {
    bs := make([]byte, 1000)
    bl := 0
   for n := 0; n < 1000; n++ {
        bl += copy(bs[bl:], "a")
    }
    fmt.Println(string(bs))
}

4.使用go语言内置函数append

package main

import (
    "bytes"
    "fmt"
)

func main() {
    bs := make([]byte, 1000)
   for n := 0; n < 1000; n++ {
        bs = append(bs,'a')
    }
    fmt.Println(string(bs))
}

5.使用字符串+运算

package main

import (
   "fmt"
)

func main() {
   var result string

   for i := 0; i < 1000; i++ {
           result += "a"
   }

   fmt.Println(result)
}

6. strings.Repeat

package main

import (
    "fmt"
    "strings"
)

func main()  {
    fmt.Println(strings.Repeat("x",1000))
}

strings.Repeat它的底层调用的是strings.Builder,提前分配了内存.

// Repeat returns a new string consisting of count copies of the string s.
//
// It panics if count is negative or if
// the result of (len(s) * count) overflows.
func Repeat(s string, count int) string {
    if count == 0 {
        return ""
    }

    // Since we cannot return an error on overflow,
    // we should panic if the repeat will generate
    // an overflow.
    // See Issue golang.org/issue/16237
    if count < 0 {
        panic("strings: negative Repeat count")
    } else if len(s)*count/count != len(s) {
        panic("strings: Repeat count causes overflow")
    }

    n := len(s) * count
    var b Builder
    b.Grow(n)
    b.WriteString(s)
    for b.Len() < n {
        if b.Len() <= n/2 {
            b.WriteString(b.String())
        } else {
            b.WriteString(b.String()[:n-b.Len()])
            break
        }
    }
    return b.String()
}

7.Benchmark

package main

import (
    "bytes"
    "strings"
    "testing"
)

const (
    sss = "https://mojotv.cn"
    cnt = 10000
)

var (
    bbb      = []byte(sss)
    expected = strings.Repeat(sss, cnt)
)
//使用 提前初始化  内置 copy函数
func BenchmarkCopyPreAllocate(b *testing.B) {
    var result string
    for n := 0; n < b.N; n++ {
        bs := make([]byte, cnt*len(sss))
        bl := 0
        for i := 0; i < cnt; i++ {
            bl += copy(bs[bl:], sss)
        }
        result = string(bs)
    }
    b.StopTimer()
    if result != expected {
        b.Errorf("unexpected result; got=%s, want=%s", string(result), expected)
    }
}
//使用 提前初始化  内置append 函数
func BenchmarkAppendPreAllocate(b *testing.B) {
    var result string
    for n := 0; n < b.N; n++ {
        data := make([]byte, 0, cnt*len(sss))
        for i := 0; i < cnt; i++ {
            data = append(data, sss...)
        }
        result = string(data)
    }
    b.StopTimer()
    if result != expected {
        b.Errorf("unexpected result; got=%s, want=%s", string(result), expected)
    }
}
//使用 提前初始化 bytes.Buffer
func BenchmarkBufferPreAllocate(b *testing.B) {
    var result string
    for n := 0; n < b.N; n++ {
        buf := bytes.NewBuffer(make([]byte, 0, cnt*len(sss)))
        for i := 0; i < cnt; i++ {
            buf.WriteString(sss)
        }
        result = buf.String()
    }
    b.StopTimer()
    if result != expected {
        b.Errorf("unexpected result; got=%s, want=%s", string(result), expected)
    }
}

//使用 strings.Repeat 本质是pre allocate + strings.Builder
func BenchmarkStringRepeat(b *testing.B) {
    var result string
    for n := 0; n < b.N; n++ {
        result = strings.Repeat(sss,cnt)
    }
    b.StopTimer()
    if result != expected {
        b.Errorf("unexpected result; got=%s, want=%s", string(result), expected)
    }
}
//使用 内置copy
func BenchmarkCopy(b *testing.B) {
    var result string
    for n := 0; n < b.N; n++ {
        data := make([]byte, 0, 64) // same size as bootstrap array of bytes.Buffer
        for i := 0; i < cnt; i++ {
            off := len(data)
            if off+len(sss) > cap(data) {
                temp := make([]byte, 2*cap(data)+len(sss))
                copy(temp, data)
                data = temp
            }
            data = data[0 : off+len(sss)]
            copy(data[off:], sss)
        }
        result = string(data)
    }
    b.StopTimer()
    if result != expected {
        b.Errorf("unexpected result; got=%s, want=%s", string(result), expected)
    }
}
//使用 内置append
func BenchmarkAppend(b *testing.B) {
    var result string
    for n := 0; n < b.N; n++ {
        data := make([]byte, 0, 64)
        for i := 0; i < cnt; i++ {
            data = append(data, sss...)
        }
        result = string(data)
    }
    b.StopTimer()
    if result != expected {
        b.Errorf("unexpected result; got=%s, want=%s", string(result), expected)
    }
}
//使用 bytes.Buffer
func BenchmarkBufferWriteBytes(b *testing.B) {
    var result string
    for n := 0; n < b.N; n++ {
        var buf bytes.Buffer
        for i := 0; i < cnt; i++ {
            buf.Write(bbb)
        }
        result = buf.String()
    }
    b.StopTimer()
    if result != expected {
        b.Errorf("unexpected result; got=%s, want=%s", string(result), expected)
    }
}
//使用 strings.Builder write bytes
func BenchmarkStringBuilderWriteBytes(b *testing.B) {
    var result string
    for n := 0; n < b.N; n++ {
        var buf strings.Builder
        for i := 0; i < cnt; i++ {
            buf.Write(bbb)
        }
        result = buf.String()
    }
    b.StopTimer()
    if result != expected {
        b.Errorf("unexpected result; got=%s, want=%s", string(result), expected)
    }
}
//使用 string buffer write string
func BenchmarkBufferWriteString(b *testing.B) {
    var result string
    for n := 0; n < b.N; n++ {
        var buf bytes.Buffer
        for i := 0; i < cnt; i++ {
            buf.WriteString(sss)
        }
        result = buf.String()
    }
    b.StopTimer()
    if result != expected {
        b.Errorf("unexpected result; got=%s, want=%s", string(result), expected)
    }
}


// 使用string 加号
func BenchmarkStringPlusOperator(b *testing.B) {
    var result string
    for n := 0; n < b.N; n++ {
        var str string
        for i := 0; i < cnt; i++ {
            str += sss
        }
        result = str
    }
    b.StopTimer()
    if result != expected {
        b.Errorf("unexpected result; got=%s, want=%s", string(result), expected)
    }
}

执行 go test -bench=. -benchmem 输出结果:

$ go test -bench=. -benchmem
goos: windows
goarch: amd64
BenchmarkCopyPreAllocate-8                 10000            117600 ns/op          344065 B/op          2 allocs/op
BenchmarkAppendPreAllocate-8               20000             75300 ns/op          344065 B/op          2 allocs/op
BenchmarkBufferPreAllocate-8               20000             97149 ns/op          344065 B/op          2 allocs/op
BenchmarkStringRepeat-8                   100000             18349 ns/op          172032 B/op          1 allocs/op
BenchmarkCopy-8                            10000            152417 ns/op          862307 B/op         13 allocs/op
BenchmarkAppend-8                          10000            157210 ns/op         1046405 B/op         23 allocs/op
BenchmarkBufferWriteBytes-8                10000            173207 ns/op          862374 B/op         14 allocs/op
BenchmarkStringBuilderWriteBytes-8         10000            155715 ns/op          874468 B/op         24 allocs/op
BenchmarkBufferWriteString-8               10000            165700 ns/op          862373 B/op         14 allocs/op
BenchmarkStringPlusOperator-8                 20          84450010 ns/op        885204590 B/op     10037 allocs/op
PASS
ok      _/D_/code/tech.mojotv.cn/tutorials      18.797s

下面着重解释下说出的结果,看到函数后面的-8了吗？这个表示运行时对应的GOMAXPROCS的值.
接着的10000表示运行for循环的次数,也就是调用被测试代码的次数,最后的174799 ns/op表示每次需要话费174799纳秒.
14 allocs/op表示每次执行分配了32字节内存.

参考文章

weixin_44151597
关注
专栏目录
Go 学习笔记（88） — 字符串拼接方法和性能、字符串组成、UTF-8 编码方案、字符串之间转换
wohu1104的专栏
09-03 722
字符串多种拼接方法和性能比对、字符串组成、UTF-8 编码方案、字符串之间转换
【Go开源宝藏】基于 Golang 语法的性能调优技巧（字符串拼接）
面向生活编程
07-17 1268
第一次写入大小为10byte的字符串时，则会申请大小为16byte(2^4)的内存（恰好大于10byte的2的指数）。在go语言中，字符串（string类型）是不可变的（如果我们需要改变字符串，就要转成byte类型，再转回string类型），因此。字符串在Go语言中是不可变类型，占用内存大小是固定的，当使用。，新空间的大小是原来两个字符串的大小之和。拼接第三个字符串时，再。，如果频繁进行字符串拼接，就会对性能产生严重的影响。拼接两个字符串时，生成一个新的字符串，那么就需要。......
Go 语言高性能编程
u014138650的专栏
12-19 677
目录 序言 关于本书 第一章 性能分析 benchmark 基准测试 pprof 性能分析 第二章 常用数据结构 字符串拼接性能及原理 切片(slice)性能及陷阱 for 和 range 的性能比较 反射(reflect)性能 第三章 并发编程 读写锁和互斥锁的性能比较 如何退出协程(超时场景) 第四章 编译优化 减小编译体积 附录 Go 语言陷阱 数组和切片 这个系列的由来 我使用 Go 作为主力编程语言已经有一年多的时间了，主要的工作职责是开发一些效
Go语言高性能的字符串拼接builder.WriteString
最新发布
运维也不仅仅是运维
01-17 258
【代码】Go语言高性能的字符串拼接builder.WriteString。
Golang语言如何高效拼接字符串？
Mark66890620
02-09 856
最近在做性能优化,有个函数里面的耗时特别长,看里面的操作大多是一些字符串拼接的操作,而字符串拼接在 golang 里面其实有很多种实现,下面这篇文章主要给大家介绍了关于Golang语言如何高效拼接字符串的相关资料,需要的朋友可以参考下 目录 01、介绍 02、操作符 + 03、strings.Join 方法 04、fmt.Sprint 方法 05、bytes.Buffer 类型 06、strings.Builder 类型 07、总结 01、介绍 在编程语言中，字符串是一种重要的数据
Go 高性能编程技法
技术能量站
09-05 445
代码的稳健、可读和高效是我们每一个 coder 的共同追求。本文将结合 Go 语言特性，为书写效率更高的代码，从常用数据结构、内存管理和并发，三个方面给出相关建议。话不多说，让我们一起学习 Go 高性能编程的技法吧。
Go语言的高性能模式 | Gopher Daily (2021.11.19) ʕ◔ϖ◔ʔ
TonyBai
11-19 353
每日一谚：Errors are normal. Errors are not exceptional.Go技术生态Istio 1.12 发布 - https://mp.weixin.qq....
go语言字符串换行_Go语言字符串高效拼接（一）
weixin_27058835的博客
12-29 2117
在我们编程的时候，和字符串打交道是必不可少的，我们对数据库里文本的处理，Web文本的显示，文本数据的存储等都需要和字符串打交道，那么对于字符串来说，查找、拼接这些都是常用的操作，尤其是以拼接使用的比较多，比如把一个人的姓名和年龄拼接在一起显示。在Go语言(golang)中，对于字符串的拼接处理有很多种方法，那么那种方法才是效率最高的呢？因为内存很贵、性能很重要，有时候不慎字符串的转换和拷贝，就可以...
Golang的五种字符串拼接方式
qq_43687652的博客
03-29 1万+
1、+号 func main() { s1 := "hello" s2 := "word" s3 := s1 + s2 fmt.Print(s3) //s3 = "helloword" } go语言用+拼接，php使用.拼接，不过由于golang中的字符串是不可变的类型，因此用 + 连接会产生一个新的字符串对效率有影响。 2、sprintf函数 s1 := "hello" s2 := "word" s3 := fmt.Sprintf("%s%s", s1, s2) //s3
性能调优之三十六计 —— 「优中取优」字符串拼接 篇
魏小言的博客
08-31 591
文章目录性能调优之三十六计 —— 「优中取优」字符串拼接 篇+ 操作符fmt.SprintfJoinbuffer.WriteStringbuffer.BuilderQ&A附录 性能调优之三十六计 —— 「优中取优」字符串拼接 篇 性能调优是每一个程序员进阶的毕竟之路，掌握各种调优技巧，对自身实力、价值的提升至关重要！继上篇 “ 原生 Echo 框架 JSON 优化 ” 之后，我们把目光转向 “ 字符串拼接 ”。 在生产开发中，“ 字符串拼接 ” 出镜率极高，像日志落地、URI 参数构造、等等众多场
经典|深入理解 Go高性能网络编程模型
极客重生
12-13 1575
导言用户空间与内核空间I/O 模型Non-blocking I/OI/O 多路复用select & pollepollGo netpoller 核心数据结构netFDpollDes...
Golang源码学习----string包
alvin_666的博客
06-23 834
String包 在go中的字符串是不可变字节序列，默认是UTF-8编码存储Unicode字符 1、分割字符串函数 主要有： SplitN：按指定的字符，将字符串分割，返回指定切片长度 Split：按指定的字符，将字符串分割 SplitAfterN：按指定字符分割，但是包含字符，返回指定切片长度 SplitAfter ：按指定字符分割，但是包含字符 Fields：用于分割字符串，不包括空格（跳过所...
golang 内置函数append使用方式
学习学习再学习
02-01 6242
内置函数append使用方式 看一下内置函数append在buildin.go中的注释就知道了 // The append built-in function appends elements to the end of a slice. If // it has sufficient capacity, the destination is resliced to accommodate the...
GoLang之内置append、copy函数
weixin_52690231的博客
03-05 1332
GoLang内置append/copy函数
golang：使用append为切片添加元素
OceanStar的博客
08-22 2211
内建函数 append() 可以为切片动态添加元素，代码如下所示： package main import "fmt" func main() { var a []int a = append(a, 1) // 追加1个元素 a = append(a, 2, 3, 4) // 追加多个元素, 手写解包方式 a = append(a, []int{5,6,7}...) // 追加一个切片, 切片需要解包 fmt.Println(a) } 需要注意的是，在使用 append() 函数为切片动态
String和StringBuilder性能测试
weixin_33709364的博客
04-29 351
public static void main(String[] args) { StopWatch s = new StopWatch(); s.start("StringBuilder"); StringBuilder sb = new StringBuilder(); for (int i = 0; i < 100...
golang 切片 append 扩容性能分析
小知识折射大智慧
09-01 1370
很多时候，我们对这个功能点不够重视，经常也会写一些没有声明 cap 容量的变量声明，然后直接调用 append，逻辑上是没有问题的，但是当 append 的数量足够多的时候，性能问题就突出来了。
Golang拼接字符串的5种方法及其效率
Chrispink
12-03 4286
package main import( "fmt" "time" "bytes" "strings" ) var loop = 100000 func main(){ var s string s1 := "hello" s2 := "world" var start time.Time //加号+连接 start = time.Now() for i := 0; i&...
golang 几种字符串的拼接方式
热门推荐
我的博客
03-14 10万+
最近在做性能优化，有个函数里面的耗时特别长，看里面的操作大多是一些字符串拼接的操作，而字符串拼接在 golang 里面其实有很多种实现。 实现方法 1.直接使用运算符 func BenchmarkAddStringWithOperator(b *testing.B) { hello := "hello" world := "world" for i := 0; i...
Go语言UTF-8编码字符串处理详解与示例
Go语言中的字符串处理方法示例详解 Go语言作为现代编程语言，其字符串类型是基于UTF-8编码的，这是Unicode字符集的一种高效且广泛使用的实现方式。在Go中，字符串是原生支持的数据类型，可以通过双引号("")或反引号...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值