go字符串拼接与性能分析

字符串拼接在golang中是非常常见的操作,本文介绍几种常用方法并分析各种方法的效率.

拼接

+ 号拼接

+ 号拼接是最常见的方式

var a string = "Hello,"
var b string = "World!"
func Test1() string {
    return a + b
}

buffer拼接

bytes 库提供一个结构体 Buffer, Buffer结构允许多次写入[]byte 、string 、rune类型的数据并一次性输出

var a string = "Hello,"
var b string = "World!"
func Test2() string {
    var buffer bytes.Buffer
    buffer.WriteString(a)
    buffer.WriteString(b)
    return buffer.String()
}

fmt.Sprint()格式化

fmt 库提供的 SprintX() 系列函数可以返回格式化后的字符串,也可用来做拼接操作

var a string = "Hello,"
var b string = "World!"
func Test3() string {
    return fmt.Sprint(a, b)
}

append拼接

字符串的底层是数组,而数组的拼接可以使用 append(),因此可以利用这一特性来进行字符串拼接操作.

var a string = "Hello,"
var b string = "World!"
func Test4() string {
    return string(append([]byte(a), []byte(b)...))
}

性能

以上介绍了比较常见的几种拼接方式,但是究竟哪种效率更高呢?下面针对 单次拼接 做一个测试,将上述代码保存为plus.go.

package plus
import (
    "bytes"
    "fmt"
)
var a string = "Hello,"
var b string = "World!"

func Test1() string {
    return a + b
}

func Test2() string {
    var buffer bytes.Buffer
    buffer.WriteString(a)
    buffer.WriteString(b)
    return buffer.String()
}

func Test3() string {
    return fmt.Sprint(a, b)
}

func Test4() string {
    return string(append([]byte(a), []byte(b)...))
}

然后编写测试脚本plus_test.go.

package plus_test

import (
    p "plus"
    "testing"
)

func BenchmarkTestPlus(b *testing.B) {
    for i := 0; i < b.N; i++ {
        p.Test1()
    }
}

func BenchmarkTestBuffer(b *testing.B) {
    for i := 0; i < b.N; i++ {
        p.Test2()
    }
}

func BenchmarkTestFormat(b *testing.B) {
    for i := 0; i < b.N; i++ {
        p.Test3()
    }
}

func BenchmarkTestAppend(b *testing.B) {
    for i := 0; i < b.N; i++ {
        p.Test4()
    }
}

运行性能测试代码 go test stringplus_test.go -bench=. 结果如下:

goos: darwin
goarch: amd64
BenchmarkTestPlus-8 100000000 22.2 ns/op
BenchmarkTestBuffer-8 20000000 102 ns/op
BenchmarkTestFormat-8 10000000 191 ns/op
BenchmarkTestAppend-8 50000000 26.4 ns/op

然后得出做一个排序,单次拼接运行时间:
+ < append()< bytes.Buffer < fmt.Sprint()

分析

+ 与 append()性能分析

+运算符为系统底层提供,无法一窥究竟.但可以由此来推断其余几种方式的运行过程, 字符串的底层是数组,姑且猜测 +方法底层就append(a,b) 的方式实习.

来看 append() 方式, 拼接期间进行了两次类型转换,分别是

字符串 a,b 转换成 []byte类型.
append()拼接后 []byte类型转为string

append()执行时间与+差距不大,由此可以推测出时间浪费在类型转换上.做一个验证:

var a string = "Hello,"
var b string = "World!"
var c = []byte{72, 101, 108, 108, 111, 44}
var d = []byte{87, 111, 114, 108, 100, 33}

func Test1() string {
    return a+b
}

func Test5() []byte {
    return append(c, d...)
}

结果出乎意料,速度反而不如转换类型后进行append()然后再转换.
goos: darwin
goarch: amd64

BenchmarkTestPlus-8 100000000 22.0 ns/op
BenchmarkTestAppend-8 50000000 26.0 ns/op
BenchmarkTestAppendByte-8 50000000 37.6 ns/op

查看append()位于 src/builtin/builtin.go 的注释得知:

对于[]slice拼接, 有 len 和 cap两个属性,并且涉及底层数组.
如果切片容量够则直接拼接,如果不够,先扩容容量再拼接.
当容量不足时,会先尝试扩容切片,如果没有连续的内存空间可以扩容,会在新的内存空间建立扩容后的切片,再将原切片拷贝过去.

append byte性能分析

原因在于数组的容量,看下面这个例子, e,f分别为转换为[]byte类型的a,b字符串

var a string = "Hello,"
var b string = "World!"
var c = []byte{72, 101, 108, 108, 111, 44}
var d = []byte{87, 111, 114, 108, 100, 33}
e := []byte(a)
f := []byte(b)
fmt.Println("c的长度:", len(c), "容量:", cap(c))
fmt.Println("d的长度:", len(d), "容量:", cap(d))
fmt.Println("e的长度:", len(e), "容量:", cap(e))
fmt.Println("f的长度:", len(f), "容量:", cap(f))

输出结果如下:

c的长度: 6 容量: 6
d的长度: 6 容量: 6
e的长度: 6 容量: 32
f的长度: 6 容量: 32

可以看到,利用[]byte()类型转换后的切片e,f,容量为32,而直接定义的切片 c,d容量仅仅为6,因此,在拼接的时候,c需要先扩容,然后再拼接,而扩容时,又会遇到迁移的问题,于是乎花费的时间反而更多.

切片迁移(拷贝)

如图1,一片连续的内存片中定义了[5]int和其他数据.当底层为[5]int的切片要拼接 6,7,8,9,10时,由于容量不够,需要扩容.可由于后续的内存地址被其他数据占据,无法形成连续的内存地址.所以会发生迁移操作.

如图2,数组在新的内存地址中申请一块长度为原容量 2倍的一块内存地址,再将原始数据拷贝过去.

数组底层的迁移.png

fmt.SprintX()性能分析

fmt库中函数,允许输入任意类型的数据,所以参数类型都是interface{},上述例子中使用的Sprint()签名如下:

func Sprint(a ...interface{}) string{}

但是在底层需要输出的时候,由于无法确定参数具体类型,于是借助了反射,src/fmt/print.go有具体实现,关键部分代码如下:

// Some types can be done without reflection.
    switch f := arg.(type) {
    case bool:
        p.fmtBool(f, verb)
    case float32:
        p.fmtFloat(float64(f), 32, verb)
    case float64:
        p.fmtFloat(f, 64, verb)
    case complex64:
        p.fmtComplex(complex128(f), 64, verb)
    case complex128:
        p.fmtComplex(f, 128, verb)
    case int:
        p.fmtInteger(uint64(f), signed, verb)
    case int8:
        p.fmtInteger(uint64(f), signed, verb)
    case int16:
        p.fmtInteger(uint64(f), signed, verb)
    case int32:
        p.fmtInteger(uint64(f), signed, verb)
    case int64:
        p.fmtInteger(uint64(f), signed, verb)
    case uint:
        p.fmtInteger(uint64(f), unsigned, verb)
    case uint8:
        p.fmtInteger(uint64(f), unsigned, verb)
    case uint16:
        p.fmtInteger(uint64(f), unsigned, verb)
    case uint32:
        p.fmtInteger(uint64(f), unsigned, verb)
    case uint64:
        p.fmtInteger(f, unsigned, verb)
    case uintptr:
        p.fmtInteger(uint64(f), unsigned, verb)
    case string:
        p.fmtString(f, verb)
    case []byte:
        p.fmtBytes(f, verb, "[]byte")
    case reflect.Value:
        // Handle extractable values with special methods
        // since printValue does not handle them at depth 0.
        if f.IsValid() && f.CanInterface() {
            p.arg = f.Interface()
            if p.handleMethods(verb) {
                return
            }
        }
        p.printValue(f, verb, 0)
    default:
        // If the type is not simple, it might have methods.
        if !p.handleMethods(verb) {
            // Need to use reflection, since the type had no
            // interface methods that could be used for formatting.
            p.printValue(reflect.ValueOf(f), verb, 0)
        }
    }

反射部分涉及reflect库,因此速度会比底层数据操作慢很多.

bytes.Buffer性能分析

来看WriteString()函数内部实现, 内部实现与append()类似,每次都需要执行tryGrowByReslice()来判断是否扩容,然后调用copy()内置函数来进行拷贝,因此拖慢了速度,但由于不涉及其他库,所以速度会快于fmt系列.

func (b *Buffer) WriteString(s string) (n int, err error) {
    b.lastRead = opInvalid
    m, ok := b.tryGrowByReslice(len(s))
    if !ok {
        m = b.grow(len(s))
    }
    return copy(b.buf[m:], s), nil
}

总结

对于简单的拼接,使用+最为便捷高效.
对于字符串与其他类型底层类型拼接,使用 类型转换 配合append()的方式比较好.
对于复杂的拼接,fmt.SpintX()与bytes.Buffer均可,前者类型支持的多一些,后者速度更快一点.