8种超简单的Golang生成随机字符串方式

本文分享自华为云社区《Golang生成随机字符串的八种方式与性能测试》，作者： 张俭。
前言

这是**icza**在StackOverflow上的一篇高赞回答，质量很高，翻译一下，大家一起学习
问题是：go语言中，有没有什么最快最简单的方法，用来生成只包含英文字母的随机字符串
icza给出了8个方案，最简单的方法并不是最快的方法，它们各有优劣，末尾附上性能测试结果：
1. Runes

比较简单的答案，声明一个rune数组，通过随机数选取rune字符，拼接成结果

1. package approach1
3. import (
4.     "fmt"
5.     "math/rand"
6.     "testing"
7.     "time"
8. )
10. var letters = []rune("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")
12. func randStr(n int) string {
13.     b := make([]rune, n)
14.     for i := range b {
15.         b[i] = letters[rand.Intn(len(letters))]
16.     }
17.     return string(b)
18. }
20. func TestApproach1(t *testing.T) {
21.     rand.Seed(time.Now().UnixNano())
22.     fmt.Println(randStr(10))
23. }
25. func BenchmarkApproach1(b *testing.B) {
26.     rand.Seed(time.Now().UnixNano())
27.     for i := 0; i < b.N; i++ {
28.         _ = randStr(10)
29.     }
30. }

复制代码

2. Bytes

如果随机挑选的字符只包含英文字母，我们可以直接使用bytes，因为在UTF-8编码模式下，英文字符和Bytes是一对一的（Go正是使用UTF-8模式编码）
所以可以把

1. var letters = []rune("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")

复制代码

用这个替代

1. var letters = []byte("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")

复制代码

或者更好

1. const letters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"

复制代码

现在我们有很大的进展了，我们把它变为了一个常数，在go里面，只有string常数，可并没有slice常数。额外的收获，表达式len(letters)也变为了一个常数（如果s为常数，那么len(s)也将是常数)
我们没有付出什么代码，现在letters可以通过下标访问其中的bytes了，这正是我们需要的。

1. package approach2
3. import (
4.     "fmt"
5.     "math/rand"
6.     "testing"
7.     "time"
8. )
10. const letters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
12. func randStr(n int) string {
13.     b := make([]byte, n)
14.     for i := range b {
15.         b[i] = letters[rand.Intn(len(letters))]
16.     }
17.     return string(b)
18. }
20. func TestApproach2(t *testing.T) {
21.     rand.Seed(time.Now().UnixNano())
23.     fmt.Println(randStr(10))
24. }
26. func BenchmarkApproach2(b *testing.B) {
27.     rand.Seed(time.Now().UnixNano())
28.     for i := 0; i < b.N; i++ {
29.         _ = randStr(10)
30.     }
31. }

复制代码

3. Remainder 余数

上面的解决方法通过rand.Intn()来获得一个随机字母，这个方法底层调用了Rand.Intn()，然后调用了Rand.Int31n()
相比于生成63个随机bits的函数rand.Int63()来说，Rand.Int31n()很慢。
我们可以简单地调用rand.Int63()然后除以len(letterBytes)，使用它的余数来生成字母

1. package approach3
3. import (
4.     "fmt"
5.     "math/rand"
6.     "testing"
7.     "time"
8. )
10. const letters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
12. func randStr(n int) string {
13.     b := make([]byte, n)
14.     for i := range b {
15.         b[i] = letters[rand.Int63() % int64(len(letters))]
16.     }
17.     return string(b)
18. }
20. func TestApproach3(t *testing.T) {
21.     rand.Seed(time.Now().UnixNano())
23.     fmt.Println(randStr(10))
24. }
26. func BenchmarkApproach3(b *testing.B) {
27.     rand.Seed(time.Now().UnixNano())
28.     for i := 0; i < b.N; i++ {
29.         _ = randStr(10)
30.     }
31. }

复制代码

这个算法能正常工作并且非常快，不过它牺牲了部分精确性，字母出现的概率并不是精确一样的（假设rand.Int63()生成63比特的数字是等概率的）。由于字母总共才52个，远小于 1= letterIdBits        remain--    }    return *(*string)(unsafe.Pointer(&b))}func TestApproach8(t *testing.T) {    fmt.Println(randStr(10))}func BenchmarkApproach8(b *testing.B) {    for i := 0; i < b.N; i++ {        _ = randStr(10)    }}[/code]Benchmark

1. package approach4
3. import (
4.     "fmt"
5.     "math/rand"
6.     "testing"
7.     "time"
8. )
10. const letters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
12. const (
13.     // 6 bits to represent a letters index
14.     letterIdBits = 6
15.     // All 1-bits as many as letterIdBits
16.     letterIdMask = 1 <<letterIdBits - 1
17. )
19. func randStr(n int) string {
20.     b := make([]byte, n)
21.     for i := range b {
22.         if idx := int(rand.Int63() & letterIdMask); idx < len(letters) {
23.             b[i] = letters[idx]
24.             i++
25.         }
26.     }
27.     return string(b)
28. }
30. func TestApproach4(t *testing.T) {
31.     rand.Seed(time.Now().UnixNano())
33.     fmt.Println(randStr(10))
34. }
36. func BenchmarkApproach4(b *testing.B) {
37.     rand.Seed(time.Now().UnixNano())
38.     for i := 0; i < b.N; i++ {
39.         _ = randStr(10)
40.     }
41. }

复制代码

原作者测试的数据
(译者注：第三列代表操作一次需要多少纳秒)

1. package approach5
3. import (
4.     "fmt"
5.     "math/rand"
6.     "testing"
7.     "time"
8. )
10. const letters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
12. const (
13.     // 6 bits to represent a letter index
14.     letterIdBits = 6
15.     // All 1-bits as many as letterIdBits
16.     letterIdMask = 1<<letterIdBits - 1
17.     letterIdMax  = 63 / letterIdBits
18. )
20. func randStr(n int) string {
21.     b := make([]byte, n)
22.     // A rand.Int63() generates 63 random bits, enough for letterIdMax letters!
23.     for i, cache, remain := n-1, rand.Int63(), letterIdMax; i >= 0; {
24.         if remain == 0 {
25.             cache, remain = rand.Int63(), letterIdMax
26.         }
27.         if idx := int(cache & letterIdMask); idx < len(letters) {
28.             b[i] = letters[idx]
29.             i--
30.         }
31.         cache >>= letterIdBits
32.         remain--
33.     }
34.     return string(b)
35. }
37. func TestApproach5(t *testing.T) {
38.     rand.Seed(time.Now().UnixNano())
40.     fmt.Println(randStr(10))
41. }
43. func BenchmarkApproach5(b *testing.B) {
44.     rand.Seed(time.Now().UnixNano())
45.     for i := 0; i < b.N; i++ {
46.         _ = randStr(10)
47.     }
48. }

复制代码

译者测试的数据

1. package approach6
3. import (
4.     "fmt"
5.     "math/rand"
6.     "testing"
7.     "time"
8. )
10. const letters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
12. var src = rand.NewSource(time.Now().UnixNano())
14. const (
15.     // 6 bits to represent a letter index
16.     letterIdBits = 6
17.     // All 1-bits as many as letterIdBits
18.     letterIdMask = 1<<letterIdBits - 1
19.     letterIdMax  = 63 / letterIdBits
20. )
22. func randStr(n int) string {
23.     b := make([]byte, n)
24.     // A rand.Int63() generates 63 random bits, enough for letterIdMax letters!
25.     for i, cache, remain := n-1, src.Int63(), letterIdMax; i >= 0; {
26.         if remain == 0 {
27.             cache, remain = src.Int63(), letterIdMax
28.         }
29.         if idx := int(cache & letterIdMask); idx < len(letters) {
30.             b[i] = letters[idx]
31.             i--
32.         }
33.         cache >>= letterIdBits
34.         remain--
35.     }
36.     return string(b)
37. }
39. func TestApproach6(t *testing.T) {
40.     fmt.Println(randStr(10))
41. }
43. func BenchmarkApproach6(b *testing.B) {
44.     for i := 0; i < b.N; i++ {
45.         _ = randStr(10)
46.     }
47. }

复制代码

现在跑出来的数据，相原作者时候，已经有了一些变化，不过并不妨碍我们看出来各个方法的趋势：

• 仅仅只是把rune切换到byte，就获得了性能的大幅度提升(大于百分之20)
  
• 使用rand.Int63()代替rand.Intn()也获得大幅度提升(大于百分之20)
  
• 使用Masking并没有提升性能，相反在原作者哪里，反而性能下降了
  
• 不过使用了一次rand.Int63()返回的全部字符后，性能提升了3倍
  
• 使用rand.Source替代rand.Rand，性能提升了21%
  
• 使用strings.Builder，我们在速度上提升了3.5%，并且把原本2次的内存分配，降低到了一次！
  
• 使用unsafe包来代替strings.Builder，性能提升了14%
  

将第八个方案和第一个方案比较，第八个方案比第一个方案快6.3倍，仅仅使用六分之一的内存，分配次数也只有原来的一半。
 
点击关注，第一时间了解华为云新鲜技术~
 

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！