Go字符串拼接 ，那种性能最佳？

相关阅读

为什么说Go字符串不能修改

使用 + 运算符连接字符串

在 Go 中连接字符串的最简单方法是使用连接运算符("+")。

func main() {
 name := "John"
 email := "john.doe@qq.com"

 s := name + "'s" + " email address is " + email

 fmt.Println(s)
}

复制

运行结果如下：

John's email address is john.doe@qq.com

复制

使用fmt.Sprint()函数，拼接字符串

在Go中，fmt.Sprint()函数用于格式化数据，因此也可以用来拼接字符串。

func main() {
 s1 := "John"
 s2 := 20

 s3 := fmt.Sprintf("[name]: %s; [age]: %d", s1, s2)

 fmt.Println(s3)
}

复制

运行结果如下：

[name]: John; [age]: 20

复制

使用strings.join()函数

func main() {
 s := []string
  "a",
  "quick",
  "brown",
  "fox",
  "jumps",
  "over",
  "the",
  "lazy",
  "dog",
 }

 fmt.Println(strings.Join(s, " ")) 

 fmt.Println(strings.Join(s, "_")) 
}

复制

最终运行的结果为：

a quick brown fox jumps over the lazy dog
a_quick_brown_fox_jumps_over_the_lazy_dog

复制

使用bytes.Buffer

func (b *Buffer) Write(p []byte) (int, error) 
func (b *Buffer) WriteByte(c byte) error
func (b *Buffer) WriteRune(r rune) (int, error)
func (b *Buffer) WriteString(s string) (int, error)

复制

a
quick
brown
fox
jumps
over
the
lazy
dog

复制

创建读取文件内容的代码：

func main() {

 var buf bytes.Buffer

 file, err := os.Open("hello.txt")
 if err != nil {
  log.Fatal(err)
 }

 scanner := bufio.NewScanner(file)
 for scanner.Scan() {
  text := strings.TrimSpace(scanner.Text())

  text = strings.ToUpper(text) + " "


  _, err := buf.WriteString(text)

  if err != nil {
   log.Fatal(err)
  }
 }

 if err := scanner.Err(); err != nil {
  log.Fatal(err)
 }

 fmt.Println(strings.TrimSpace(buf.String()))

}

复制

最终运行结果如下：

A QUICK BROWN FOX JUMPS OVER THE LAZY DOG

复制

使用strings.Builder

func main() {

 var builder strings.Builder


 file, err := os.Open("hello.txt")
 if err != nil {
  log.Fatal(err)
 }

 scanner := bufio.NewScanner(file)
 for scanner.Scan() {
  text := strings.TrimSpace(scanner.Text())

  text = strings.ToUpper(text) + " "

  _, err := builder.WriteString(text)

  if err != nil {
   log.Fatal(err)
  }
 }

 if err := scanner.Err(); err != nil {
  log.Fatal(err)
 }

 fmt.Println(strings.TrimSpace(builder.String()))

}

复制

最终输出的结果如下：

A QUICK BROWN FOX JUMPS OVER THE LAZY DOG

复制

基准测试

package main

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

var loremIpsum = `
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Maecenas non odio eget quam gravida laoreet vitae id est. Cras sit amet porta dui. Pellentesque at pulvinar ante. Pellentesque leo dolor, tristique a diam vel, posuere rhoncus ex. Mauris gravida, orci eu molestie pharetra, mi nibh bibendum arcu, in bibendum augue neque ac nulla. Phasellus consectetur turpis et neque tincidunt molestie. Vestibulum diam quam, sodales quis nulla eget, volutpat euismod mauris.
`

var strSLice = make([]string, LIMIT)

const LIMIT = 1000

func init() {
 for i := 0; i < LIMIT; i++ {
  strSLice[i] = loremIpsum
 }
}

func BenchmarkConcatenationOperator(b *testing.B) {
 for i := 0; i < b.N; i++ {
  var q string
  for _, v := range strSLice {
   q = q + v
  }
 }
 b.ReportAllocs()
}

func BenchmarkFmtSprint(b *testing.B) {
 for i := 0; i < b.N; i++ {
  var q string
  for _, v := range strSLice {
   q = fmt.Sprint(q, v)
  }
 }
 b.ReportAllocs()
}

func BenchmarkStringsJoin(b *testing.B) {
 for i := 0; i < b.N; i++ {
  q := strings.Join(strSLice, "")

  _ = q
 }
 b.ReportAllocs()
}

func BenchmarkBytesBuffer(b *testing.B) {
 for i := 0; i < b.N; i++ {
  var q bytes.Buffer

  q.Grow(len(loremIpsum) * len(strSLice))

  for _, v := range strSLice {
   q.WriteString(v)
  }
  _ = q.String()
 }
 b.ReportAllocs()
}

func BenchmarkStringBuilder(b *testing.B) {
 for i := 0; i < b.N; i++ {
  var q strings.Builder

  q.Grow(len(loremIpsum) * len(strSLice))

  for _, v := range strSLice {
   q.WriteString(v)
  }
  _ = q.String()
 }
 b.ReportAllocs()
}

复制

使用如下命令，查看运行结果：

go test -bench=.

复制

最终输出结果：

goos: linux
goarch: amd64
pkg: github.com/Freshman-tech/golang
cpu: Intel(R) Core(TM) i7-10875H CPU @ 2.30GHz
BenchmarkConcatenationOperator-16             51          24837485 ns/op        238062937 B/op      1009 allocs/op
BenchmarkFmtSprint-16                         21          53225816 ns/op        488510658 B/op      5146 allocs/op
BenchmarkStringsJoin-16                    27043             43857 ns/op          475137 B/op          1 allocs/op
BenchmarkBytesBuffer-16                    15705             76785 ns/op          950274 B/op          2 allocs/op
BenchmarkStringBuilder-16                  29877             40188 ns/op          475136 B/op          1 allocs/op
PASS
ok      github.com/Freshman-tech/golang 7.687s

复制