字符串操作

对于任何一门语言来说，字符串的操作都是最常见的操作。

字符串长度

len(yourStr)
有的时候判断字符串是否为空，可以使用if len(yourStr){},这个方法和if yourStr == “” { }效果相同。

字符串截取

yourStr[开始:结束]

  1. yourStr := "Mr. Watson, Come Here, I Want You!"
  2. fmt.Println(yourStr[4:16]) //out [Watson, Come]

字符串切割方法

func Fields(s string) []string，这个函数的作用是按照1：n个空格来分割字符串最后返回的是
[]string的切片

  1. yourStr = "Mr.              Watson, Come       Here, I          Want    You!"
  2. fmt.Println(strings.Fields(yourStr)) //out  [Mr. Watson, Come Here, I Want You!]

func FieldsFunc(s string, f func(rune) bool) []string一看就了解了，这就是根据自定义函数分割了

  1. func Sunnysplit(s rune) bool {
  2.     if s == '$' {
  3.         return true
  4.     }
  5.     return false
  6. }
  8. yourStr = "Mr.$Watson,$Come$Here,$I$Want$You!"
  9. fmt.Println(strings.FieldsFunc(yourStr, Sunnysplit)) //out  [Mr. Watson, Come Here, I Want You!]

func Split(s, sep string) []string,把字符串按照指定的分隔符切割成slice

  1. yourStr = "Mr.$Watson,$Come$Here,$I$Want$You!"
  2. fmt.Println(strings.Split(yourStr, "$")) //out  [Mr. Watson, Come Here, I Want You!]

func SplitAfter(s, sep string) []string,这个函数是在前边的切割完成之后再后边在加上sep分割符

  1. yourStr = "Mr.$Watson,$Come$Here,$I$Want$You!"
  2.     fmt.Println(strings.SplitAfter(yourStr, "$")) //out  [Mr.$ Watson,$ Come$ Here,$ I$ Want$ You!]

字符串查找

strings.Index(“Mr. Watson, Come Here, I Want You!”, “Come”) 结果为12

strings.Index(“Mr. Watson, Come Here, I Want You!”, “ff”) 结果为-1

字符串和数字的相互转换

字符串与数字的相互转换，主要在strconv这个包里面.

与整数的相互转换

字符串变数字strconv.Atoi()

  1. func JudgeType(e interface{}) (result string) {
  2.     switch e.(type) {
  3.     case int:
  4.         result = "整型"
  5.         break
  6.     case string:
  7.         result = "字符串"
  8.         break
  9.     }
  10.     return
  11. }
  12. yourStr = "123456789"
  13. yourNumber, error := strconv.Atoi(yourStr)
  14. if error != nil {
  15.     fmt.Println("字符串转换成整数失败")
  16. } else {
  17.     fmt.Println(JudgeType(yourNumber),yourNumber)
  18. }
  19. //out 整型 123456789

也可以使用fmt.Sprintf来把数值转换为字符串

  1. yourNumberFloat := "1234.56789"
  2. yourStr = fmt.Sprintf("%f", yourNumberFloat)
  3. fmt.Println(JudgeType(yourStr), yourStr)
  4. //out  字符串 %!f(string=1234.56789)

数字变字符串strconv.Itoa()

  1. yournumber = 123456789
  2. yourStr = strconv.Itoa(yourNumber)
  3. fmt.Println(JudgeType(yourStr), yourStr)
  4. //字符串 123456789

字符串替换

strings.Replace()

  1. yourStr = "Mr.$Watson,$Come$Here,$I$Want$You!"
  2. fmt.Println(strings.Replace(yourStr, "$", " ", -1)) //out  Mr. Watson, Come Here, I Want You!

字符串与[]byte的相互转换

  1. import (
  2.     "reflect"
  3.     "unsafe"
  4. )
  5. func JudgeType(e interface{}) (result string) {
  6.     switch e.(type) {
  7.     case int:
  8.         result = "整型"
  9.         break
  10.     case string:
  11.         result = "字符串"
  12.         break
  13.     case []byte:
  14.         result = "[]bytes"
  15.         break
  16.     }
  17.     return
  18. }
  20. func Byte2Str(buf []byte) string {
  21.     return *(*string)(unsafe.Pointer(&buf))
  22. }
  24. func Str2Byte(s *string) []byte {
  25.     return *(*[]byte)(unsafe.Pointer((*reflect.SliceHeader)(unsafe.Pointer(s))))
  26. }
  28. yourStr = "Mr. Watson, Come Here, I Want You!"
  29. yourByte := Str2Byte(&yourStr)
  30. fmt.Println(JudgeType(yourByte), yourByte)
  32. //out []bytes [77 114 46 36 87 97 116 115 111 110 44 36 67 111 109 101 36 72 101 114 101 44 36 73 36 87 97 110 116 36 89 111 117 33]
  34. yourStr = Byte2Str(yourByte)
  35. fmt.Println(JudgeType(yourStr), yourStr)
  36. //out 字符串 Mr. Watson, Come Here, I Want You!

字符串去除空格

strings.Trim()

  1. yourStr = "   Mr. Watson, Come Here, I Want You!  "
  2. fmt.Println(strings.Trim(yourStr, " "))
  3. //第二个参数是指trim掉什么字符，这个和很多语言不相同

strings.TrimSpace()

  1. yourStr = "\r\n\t   Mr. Watson, Come Here, I Want You!  \r\n\t"
  2. fmt.Println(strings.TrimSpace(yourStr))
  3. //这个是把所有的空格类的字符全部trim掉

查找子串是否在指定的字符串中

strings.Contains(“Mr. Watson, Come Here, I Want You!”, “Come”) 结果为true

strings.Contains(“Mr. Watson, Come Here, I Want You!”, “ff”) 结果为false

strings.Contains(“Mr. Watson, Come Here, I Want You!”, “”) 结果为true

strings.Contains(“”, “”) 特别注意，这个结果为true

查找子串替换大小写

strings.ToLower()全部替换为小写

strings.ToUpper()全部替换为大写

pro03_10.go

Go语言中字符串的拼装方法很多，那么问题来了，到底哪家性能好？

下面代码，分别比较了 fmt.Sprintf，string +，strings.Join，bytes.Buffer，方法是循环若干次比较总时间。

在VMWare下的Ubuntu 14.04下运行的结果表明：

fmt.Sprintf 和 strings.Join 速度相当
string + 比上述二者快一倍
bytes.Buffer又比上者快约400-500倍
如果循环内每次都临时声明一个bytes.Buffer来使用，会比持续存在慢50%，但是仍然很快
测试代码如下：

  1. package main
  3. import (
  4.     "bytes"
  5.     "fmt"
  6.     "strings"
  7.     "time"
  8. )
  10. var way map[int]string
  12. func benchmarkStringFunction(n int, index int) (d time.Duration) {
  13.     v := "ni shuo wo shi bu shi tai wu liao le a?"
  14.     var s string
  15.     var buf bytes.Buffer
  17.     t0 := time.Now()
  18.     for i := 0; i < n; i++ {
  19.         switch index {
  20.         case 0: // fmt.Sprintf
  21.             s = fmt.Sprintf("%s[%s]", s, v)
  22.         case 1: // string +
  23.             s = s + "[" + v + "]"
  24.         case 2: // strings.Join
  25.             s = strings.Join([]string{s, "[", v, "]"}, "")
  26.         case 3: // stable bytes.Buffer
  27.             buf.WriteString("[")
  28.             buf.WriteString(v)
  29.             buf.WriteString("]")
  30.         }
  32.     }
  33.     d = time.Since(t0)
  34.     if index == 3 {
  35.         s = buf.String()
  36.     }
  37.     fmt.Printf("string len: %d\t", len(s))
  38.     fmt.Printf("time of [%s]=\t %v\n", way[index], d)
  39.     return d
  40. }
  42. func main() {
  43.     way = make(map[int]string, 5)
  44.     way[0] = "fmt.Sprintf"
  45.     way[1] = "+"
  46.     way[2] = "strings.Join"
  47.     way[3] = "bytes.Buffer"
  49.     k := 4
  50.     d := [5]time.Duration{}
  51.     for i := 0; i < k; i++ {
  52.         d[i] = benchmarkStringFunction(10000, i)
  53.     }
  54. }

测试的结果很惊人

  1. string len: 410000    time of [fmt.Sprintf]=     359.41771ms
  2. string len: 410000    time of [+]=     245.564328ms
  3. string len: 410000    time of [strings.Join]=     581.570649ms
  4. string len: 410000    time of [bytes.Buffer]=     484.275µs
  • trings.Join 最慢
  • fmt.Sprintf 和 string + 差不多

  • bytes.Buffer又比上者快约500倍

  • +操作符 通过汇编可知实现在runtime/string.go中， 主要是concatstrings函数 短字符串优化，没有借助[]byte造成转换string的消耗，故单次调用+操作符是最快的。灵活性最差

  • bytes.Buffer 源码实现在bytes/buffer.go中 小内存优化，能提前预分配内存，内存不足时*2倍增长，但是最后获取string结果有[]byte转string的消耗，故bytes.Buffer在一次初始化（提前计算总长度，一次性预分配好内存更好），多次字符串连接操作，最后一次性获取string结果的场景中是最快的。灵活性是最强的
  • strings.Join 源码实现在strings/strings.go中 少量字符串连接优化，一次性分配内存，有[]byte转换string的消耗，故单次调用能达到bytes.Buffer的最好效果，但是它不够灵活
  • fmt.Sprintf 源码实现在fmt/print.go中 因为a…interface{}有参数转换的消耗， 借助[]byte每次添加调用append，逻辑相对复杂，最后获取结果有[]byte转string的消耗，故fmt.Sprintf一般要慢于bytes.Buffer和strings.Join，灵活性和strings.Join差不多
  • 结论
    • 单次调用性能：操作符+>strings.Join>=bytes.Buffer>fmt.Sprintf
    • 灵活性：bytes.Buffer>fmt.Sprintf>=strings.Join>操作符+
    • 正确使用，多次连接字符串操作的情况下，bytes.Buffer应该是最快的。

在go 1.10中有了新的strings.Builder

链接