golang -- 字符串就地取反

字符串

定义

在golang中字符串是一种不可变的字节序列，它可以包含任意的数据，包括0值字节，但主要是人类可以阅读的文本。golang中默认字符串被解读为utf-8编码的Unicode码点（文字符号）序列。

特性

golang中字符串具有不可变性。例如

str := "hello 世界！"

str[0] = 'L'

这种写法会引起编译错误:str[0] 不可赋值

字符串支持类似数组中分片的引用写法：

fmt.Println(str[:5]) // 输出 hello

fmt.Println(str[7:]) // 输出 世界

fmt.Println(str[len(s)+1:) // 宕机

str[i:j] , 当i、j 越界 （j 、i < 0 或 j、i > len(str) ）或 j < i 时会发生宕机。

str := "Hello"

t := str

str += "world"

这种写法可以通过，虽然str指向了一个新的字符串“Hello world”，但t指向的旧字符串仍然存在。

不可变意味着两个字符串能够安全的共享同一段底层内存，是的复制任何长度字符串的开销都低廉，类似的字符串s及其子串（s[n:]）字符串的复制也开销低廉。

常见问题

1. 顺序输出字符串中的每一个字符。

这个问题乍一看十分的简单，直接遍历就好了：

str := "Hello 世界！" 

for i := 0; i < len(str) ; i++{
    fmt.Printf(“%c \t”,str[i])
}

然而事实没那么简单，其输出结果如下：

H	e	l	l	o	 	ä	¸	­	å	›	½	ï	¼	

中文字符部分全部为乱码。这与utf-8的编码规则有关， utf-8是以字节为单位对unicode码点进行变长编码。每一个文字符号用1_{4个字节表示，ASCII字符仅仅占1字节的内存，其他常用的文书符号会占到2}3个字节。一个字符编码的首字节高位指明后面还有多少个字节：

规则	表示范围	说明
0xxxxxxx	文字符号0~127	Ascii 字符
110xxxxx 10xxxxxx	128~2047	少于128个未使用的值
1110xxxxx 10xxxxxx 10xxxxxx	2048~65535	少于2048个未使用的值
1110xxxxx 10xxxxxx 10xxxxxx 10xxxxxx	65536~0x10ffffff	其他未使用值

在上面提到的例子里面Hello子串中的字符为Ascii字符，占用一个字节， 而 世界这两个符号占用的字符为 3 个，所以遍历的时候会出现乱码的情况。

我们这里换一种写法：

for i , v := range str {
    fmt.Printf("%d\t%c\n", i , v)
}

其显示结果如下：

0	H
1	e
2	l
3	l
4	o
5
6	中
9	国
12 ！

以上代码正常的输出了每一个字符包括中文字符。为什么使用range会成功？ 因为range在循环的同时进行了隐式的解码。其中 i 表示该字符在字符串中起始的下角标，v要重点说一下，它表示的是字符对应的unicode 点码，在golang中它有一个专门的变量类型 rune （文字符号） ，它是int32类型的别名。在golang中int占用内存大小取决于操作系统底层和计算机硬件，但int32一定是占用 4 bytes ，rune类型在打印输出的时候使用“%c”。

有了能遍历输出的函数自然很容易的就可以写出取反函数：

func Reverse(str string)(res string)  {
	for _, v := range str {
		res = string(v) + res
	}

	return
}

分析和优化

我们测试一下这个函数的性能：

func BenchmarkReverse1(b *testing.B) {
	tStr := "Hello 中国！"
	for i := 0; i < b.N; i++{
		Reverse(tStr)
	}
}

作者在winx10/arm64 的操作系统中进行测试，cpu 为core i3，内存为 4g（硬件设施比较老旧了），最后得出的分析结果如下：

goos: windows
goarch: amd64
pkg: project/learn/chapeter2
BenchmarkReverse1-4   	 2000000	       788 ns/op
PASS

ROUTINE ======================== project/learn/chapeter2.Reverse1 in D:\gopath\src\project\learn\chapeter2\str.go

 250ms      2.25s (flat, cum) 94.54% of Total
     .          .     14:
     .          .     15:   res = string(rnStr)
     .          .     16:   return
     .          .     17:}
     .          .     18:
  20ms       20ms     19:func Reverse1(str string)(res string)  {
     .          .     20:
  80ms      110ms     21:   for _, v := range str {
 150ms      2.12s     22:           res = string(v) + res
     .          .     23:           //res = fmt.Sprintf("%c%s", v ,res)
     .          .     24:   }
     .          .     25:
     .          .     26:   return
     .          .     27:}

可以看见最耗时的操作就是res 重新赋值的部分，此时有两种情况：1、res字符串执行 + 操作很费时； 2、进行字符转化的时候费时，我们把代码调整一下：

func Reverse(str string)(res string)  {
	for _, v := range str {
                temp := string(v)
		res = temp + res
	}

	return
}

性能测试结果如下

ROUTINE ======================== project/learn/chapeter2.Reverse1 in D:\gopath\src\project\learn\chapeter2\str.go

 230ms      2.31s (flat, cum) 93.90% of Total
     .          .     14:
     .          .     15:   res = string(rnStr)
     .          .     16:   return
     .          .     17:}
     .          .     18:
  10ms       10ms     19:func Reverse1(str string)(res string)  {
  90ms      210ms     20:   for _, v := range str {
  30ms      200ms     21:           temp := string(v)
  90ms      1.88s     22:           res = temp + res
     .          .     23:
     .          .     24:   }
     .          .     25:
  10ms       10ms     26:   return
     .          .     27:}
     .          .     28:

可见res 执行 + 操作要更费时一些，在执行+操作的过程中，要经历 字符串拷贝、底层字节数组内存重新分配（可能被触发）。

优化的思路很简单，创建一片‘缓存’，用来存储字符串对应的字节数据，最后再统一转化为字符串。

func Reverse(str string)(res string)  {
	i:=0
	cache := make([]byte, len(str))

	for _, v := range str {
		i += utf8.RuneLen(v)
		utf8.EncodeRune(cache[len(str) - i:], v)
	}

	res = string(cache)
	return
}

执行结果如下：

goos: windows
goarch: amd64
pkg: project/learn/chapeter2
BenchmarkReverse2-4      5000000               253 ns/op
PASS
ok      project/learn/chapeter2 1.831s

ROUTINE ======================== project/learn/chapeter2.Reverse2 in D:\gopath\src\project\learn\chapeter2\str.go

 510ms      1.45s (flat, cum) 90.62% of Total
     .          .     29:
  20ms       20ms     30:func Reverse2(str string)(res string)  {
     .          .               31:   i:=0
  20ms      210ms     32:   cache := make([]byte, len(str))
     .          .     33:
 280ms      460ms     34:   for _, v := range str {
  50ms       90ms     35:           i += utf8.RuneLen(v)
 100ms      250ms     36:         utf8.EncodeRune(cache[len(str) - i:], v)
     .          .     37:   }
     .          .     38:
  20ms      400ms     39:   res = string(cache)
  20ms       20ms     40:   return
     .          .     41:}

优化率接近68%。从以上过程我们可以对golang的字符串类型的变量有一个直观的认识。