performance - 字符串连接的性能比较

Question

This question already has answers here:

How to efficiently concatenate strings in go

(18个回答)


在11个月前关闭。




我正在尝试找出 字符串的使用。相比于+ = 的 常规连接，请加入方法。

为了进行比较，我在os.Args上同时使用了这两种方法作为要连接的字符串列表。

我的串联函数代码是:

func regular_concatenation() {
    var s, sep string
    for i := 1; i < len(os.Args); i++ {
        s += sep + os.Args[i]
        sep = " "
    }
    fmt.Println(s)
}

func join_concatenation() {
    fmt.Println(strings.Join(os.Args, " "))
}

性能检查的主要功能是:

func main() {
    var end_1, end_2 float64
    var start_1, start_2 time.Time

    start_1 = time.Now()
    for i:=0; i < 100; i++ {
        ex1_3_join_concatenation()
    }
    end_1 = time.Since(start_1).Seconds()

    start_2 = time.Now()
    for i:=0; i < 100; i++ {
        ex1_3_regular_concatenation()
    }
    end_2 = time.Since(start_2).Seconds()

    fmt.Println(end_1)
    fmt.Println(end_2)
}

问题是-当我运行代码并说20个参数(os.Args)时，我得到的结果是 字符串。Join方法比常规的混叠慢。

这让我感到困惑，因为我的理解方式-使用常规+ =方法时，它每次都会创建一个新的字符串引用(因为字符串在golang中是不可变的)，因此应该运行垃圾收集器以收集未使用的数据，这会浪费时间。

所以问题是-字符串连接真的是一种更快的方法吗？如果是的话-在这个例子中我做错了什么？

最佳答案

由于各种编译器优化，字符串连接可能非常有效，但是在您的情况下，我发现strings.Join更快(请参见下面的代码基准)。

通常，为了构建字符串，建议使用strings.Builder。参见How to efficiently concatenate strings in go。

顺便说一句，您应该使用Go随附的出色基准测试工具。只需将这些函数放在以_test.go结尾的文件中(例如string_test.go)，然后运行go test -bench=.即可。

func BenchmarkConcat(b *testing.B) { // 132 ns/op
    ss := []string {"sadsadsa", "dsadsakdas;k", "8930984"}
    for i := 0; i < b.N; i++ {
        var s, sep string
        for j := 0; j < len(ss); j++ {
            s += sep + ss[j]
            sep = " "
        }
        _ = s
    }
}

func BenchmarkJoin(b *testing.B) {  // 56.7 ns/op
    ss := []string {"sadsadsa", "dsadsakdas;k", "8930984"}
    for i := 0; i < b.N; i++ {
        s := strings.Join(ss, " ")
        _ = s
    }
}

func BenchmarkBuilder(b *testing.B) { // 58.5
    ss := []string {"sadsadsa", "dsadsakdas;k", "8930984"}
    for i := 0; i < b.N; i++ {
        var s strings.Builder
        // Grow builder to expected max length (maybe this
        // needs to be calculated dep. on your requirements)
        s.Grow(32)
        var sep string
        for j := 0; j < len(ss); j++ {
            s.WriteString(ss[j])
            s.WriteString(sep)
            sep = " "
        }
        _ = s.String()
    }
}

关于performance - 字符串连接的性能比较，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/60688270/

上一篇：r - sparklyr hadoop配置

下一篇：使用 golang 进行 Json 编码

Answer 1

由于各种编译器优化，字符串连接可能非常有效，但是在您的情况下，我发现strings.Join更快(请参见下面的代码基准)。

通常，为了构建字符串，建议使用strings.Builder。参见How to efficiently concatenate strings in go。

顺便说一句，您应该使用Go随附的出色基准测试工具。只需将这些函数放在以_test.go结尾的文件中(例如string_test.go)，然后运行go test -bench=.即可。

func BenchmarkConcat(b *testing.B) { // 132 ns/op
    ss := []string {"sadsadsa", "dsadsakdas;k", "8930984"}
    for i := 0; i < b.N; i++ {
        var s, sep string
        for j := 0; j < len(ss); j++ {
            s += sep + ss[j]
            sep = " "
        }
        _ = s
    }
}

func BenchmarkJoin(b *testing.B) {  // 56.7 ns/op
    ss := []string {"sadsadsa", "dsadsakdas;k", "8930984"}
    for i := 0; i < b.N; i++ {
        s := strings.Join(ss, " ")
        _ = s
    }
}

func BenchmarkBuilder(b *testing.B) { // 58.5
    ss := []string {"sadsadsa", "dsadsakdas;k", "8930984"}
    for i := 0; i < b.N; i++ {
        var s strings.Builder
        // Grow builder to expected max length (maybe this
        // needs to be calculated dep. on your requirements)
        s.Grow(32)
        var sep string
        for j := 0; j < len(ss); j++ {
            s.WriteString(ss[j])
            s.WriteString(sep)
            sep = " "
        }
        _ = s.String()
    }
}