1. package main
    3. import (
    4.     "bytes"
    5.     "fmt"
    6.     "log"
    7.     "strings"
    8. )
    10. // 最常用的方法肯定是+连接两个字符串。这与python类似,不过由于golang中的字符串是不可变的类型,因此用+连接会产生一个新的字符串对效率有影响。
    11. func f1() {
    12.     s1 := "字符串"
    13.     s2 := "拼接"
    14.     s3 := s1 + s2
    15.     log.Println("f1", s3) // 字符串拼接
    16. }
    18. // 2.第二种方法使用sprintf函数,虽然不会像直接使用+那样产生临时字符串。但是效率也不高
    20. func f2() {
    21.     s1 := "字符串"
    22.     s2 := "拼接"
    23.     s3 := fmt.Sprintf("%s%s", s1, s2)
    24.     log.Println("f2", s3)
    25. }
    27. // 第三种方法是用Join函数,这里我们需要先引入strings包才能调用Join函数。
    28. // Join函数会先根据字符串数组的内容,计算出一个拼接之后的长度,然后申请对应大小的内存,
    29. // 一个一个字符串填入,在已有一个数组的情况下,这种效率会很高,如果没有的话效率也不高。
    30. func f3() {
    31.     s1 := []string{
    32.         "字符串",
    33.         "拼接",
    34.     }
    35.     s2 := strings.Join(s1, "") //第二个参数可以设置拼接分隔符
    36.     log.Println("f3", s2)
    37. }
    39. // 第四个方法是调用 buffer.WriteString 函数,这种方法的性能就要大大优于上面的了。
    40. func f4() {
    41.     s1 := "字符串"
    42.     s2 := "拼接"
    43.     var bt bytes.Buffer
    44.     bt.WriteString(s1)
    45.     bt.WriteString(s2)
    46.     log.Println("f4", bt.String())
    47. }
    49. // 第5个方法是用buffer.Builder,这个方法和上面的差不多,不过官方建议用这个,使用方法和上面基本一样 需要先导入String 包
    50. func f5() {
    51.     s1 := "字符串"
    52.     s2 := "拼接"
    53.     var build strings.Builder
    54.     build.WriteString(s1)
    55.     build.WriteString(s2)
    56.     s3 := build.String()
    57.     log.Println("f5", s3)
    58. }
    60. func main() {
    61.     log.SetFlags(log.Lshortfile)
    62.     f1()
    63.     f2()
    64.     f3()
    65.     f4()
    66.     f5()
    67.     // 一般对于少量的字符串拼接可以直接用+来连接,不过最好的方法还是Builder。
    68. }
    1. main.go:15: f1 字符串拼接
    2. main.go:24: f2 字符串拼接
    3. main.go:36: f3 字符串拼接
    4. main.go:46: f4 字符串拼接
    5. main.go:57: f5 字符串拼接