8種超簡單的Golang生成隨機字符串方式分享

更新時間：2024年01月08日 10:27:38 作者：張儉

這篇文章主要為大家詳細介紹了8種超簡單的Golang生成隨機字符串方式,文中的示例代碼講解詳細,感興趣的小伙伴可以跟隨小編一起學習一下

前言

這是icza在StackOverflow上的一篇高贊回答，質(zhì)量很高，翻譯一下，大家一起學習

問題是：go語言中，有沒有什么最快最簡單的方法，用來生成只包含英文字母的隨機字符串

icza給出了8個方案，最簡單的方法并不是最快的方法，它們各有優(yōu)劣，末尾附上性能測試結(jié)果：

1. Runes

比較簡單的答案，聲明一個rune數(shù)組，通過隨機數(shù)選取rune字符，拼接成結(jié)果

package approach1

import (
    "fmt"
    "math/rand"
    "testing"
    "time"
)

var letters = []rune("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")

func randStr(n int) string {
    b := make([]rune, n)
    for i := range b {
        b[i] = letters[rand.Intn(len(letters))]
    }
    return string(b)
}

func TestApproach1(t *testing.T) {
    rand.Seed(time.Now().UnixNano())
    fmt.Println(randStr(10))
}

func BenchmarkApproach1(b *testing.B) {
    rand.Seed(time.Now().UnixNano())
    for i := 0; i < b.N; i++ {
        _ = randStr(10)
    }
}

2. Bytes

如果隨機挑選的字符只包含英文字母，我們可以直接使用bytes，因為在UTF-8編碼模式下，英文字符和Bytes是一對一的（Go正是使用UTF-8模式編碼）

所以可以把

var letters = []rune("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")

用這個替代

var letters = []byte("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")

或者更好

const letters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"

現(xiàn)在我們有很大的進展了，我們把它變?yōu)榱艘粋€常數(shù)，在go里面，只有string常數(shù)，可并沒有slice常數(shù)。額外的收獲，表達式len(letters)也變?yōu)榱艘粋€常數(shù)（如果s為常數(shù)，那么len(s)也將是常數(shù))

我們沒有付出什么代碼，現(xiàn)在letters可以通過下標訪問其中的bytes了，這正是我們需要的。

package approach2

import (
    "fmt"
    "math/rand"
    "testing"
    "time"
)

const letters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"

func randStr(n int) string {
    b := make([]byte, n)
    for i := range b {
        b[i] = letters[rand.Intn(len(letters))]
    }
    return string(b)
}

func TestApproach2(t *testing.T) {
    rand.Seed(time.Now().UnixNano())

    fmt.Println(randStr(10))
}

func BenchmarkApproach2(b *testing.B) {
    rand.Seed(time.Now().UnixNano())
    for i := 0; i < b.N; i++ {
        _ = randStr(10)
    }
}

3. Remainder 余數(shù)

上面的解決方法通過rand.Intn()來獲得一個隨機字母，這個方法底層調(diào)用了Rand.Intn()，然后調(diào)用了Rand.Int31n()

相比于生成63個隨機bits的函數(shù)rand.Int63()來說，Rand.Int31n()很慢。

我們可以簡單地調(diào)用rand.Int63()然后除以len(letterBytes)，使用它的余數(shù)來生成字母

package approach3

import (
    "fmt"
    "math/rand"
    "testing"
    "time"
)

const letters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"

func randStr(n int) string {
    b := make([]byte, n)
    for i := range b {
        b[i] = letters[rand.Int63() % int64(len(letters))]
    }
    return string(b)
}

func TestApproach3(t *testing.T) {
    rand.Seed(time.Now().UnixNano())

    fmt.Println(randStr(10))
}

func BenchmarkApproach3(b *testing.B) {
    rand.Seed(time.Now().UnixNano())
    for i := 0; i < b.N; i++ {
        _ = randStr(10)
    }
}

這個算法能正常工作并且非?？?，不過它犧牲了部分精確性，字母出現(xiàn)的概率并不是精確一樣的（假設(shè)rand.Int63()生成63比特的數(shù)字是等概率的）。由于字母總共才52個，遠小于 1<<63 - 1，因此失真非常小，因此實際上這完全沒問題。

解釋: 假設(shè)你想要0~5的隨機數(shù)，如果使用3位的bit，3位的bit等概率出現(xiàn)0~7，所以出現(xiàn)0和1的概率是出現(xiàn)2、3、4概率的兩倍。使用5位的 bit，0和1出現(xiàn)的概率是6/32，2、3、4出現(xiàn)的概率是5/32。現(xiàn)在接近了一些了，是吧？不斷地增加比特位，這個差距就會變得越小，當你有63位地時候，這差別已經(jīng)可忽略不計。

4. Masking 掩碼

在上一個方案的基礎(chǔ)上，我們通過僅使用隨機數(shù)的最低n位保持均勻分布，n表示所有字符的數(shù)量。比如我們有52個字母，我們需要6位（52 = 110100b）。所以我們僅僅使用了rand.Int63()的最后6位。并且，為了保持所有字符的均勻分布，我們決定只接受在0..len(letterBytes)-1的數(shù)字即0~51。（譯者注：這里已經(jīng)沒有第三個方案的不準確問題了）

最低幾位大于等于len(letterBytes)的概率一般小于0.5（平均值為0.25），這意味著出現(xiàn)這種情況，只要重試就好。重試n次之后，我們?nèi)匀恍枰獊G棄這個數(shù)字的概率遠小于0.5的n次方（這是上界了，實際會低于這個值）。以本文的52個字母為例，最低6位需要丟棄的概率只有(64-52)/64=0.19。這意味著，重復10次，仍然沒有數(shù)字的概率是1*10^-8。

package approach4

import (
    "fmt"
    "math/rand"
    "testing"
    "time"
)

const letters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"

const (
    // 6 bits to represent a letters index
    letterIdBits = 6
    // All 1-bits as many as letterIdBits
    letterIdMask = 1 <<letterIdBits - 1
)

func randStr(n int) string {
    b := make([]byte, n)
    for i := range b {
        if idx := int(rand.Int63() & letterIdMask); idx < len(letters) {
            b[i] = letters[idx]
            i++
        }
    }
    return string(b)
}

func TestApproach4(t *testing.T) {
    rand.Seed(time.Now().UnixNano())

    fmt.Println(randStr(10))
}

func BenchmarkApproach4(b *testing.B) {
    rand.Seed(time.Now().UnixNano())
    for i := 0; i < b.N; i++ {
        _ = randStr(10)
    }
}

5. Masking Improved

第4節(jié)的方案只使用了rand.Int63()方法返回的64個隨機字節(jié)的后6位。這實在是太浪費了，因為rand.Int63()是我們算法中最耗時的部分了。

如果我們有52個字母，6位就能生成一個隨機字符串。所以63個隨機字節(jié)，可以利用63/6=10次。

譯者注：使用了緩存，緩存了rand.Int63()方法返回的內(nèi)容，使用10次，不過已經(jīng)并不是協(xié)程安全的了。

package approach5

import (
    "fmt"
    "math/rand"
    "testing"
    "time"
)

const letters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"

const (
    // 6 bits to represent a letter index
    letterIdBits = 6
    // All 1-bits as many as letterIdBits
    letterIdMask = 1<<letterIdBits - 1
    letterIdMax  = 63 / letterIdBits
)

func randStr(n int) string {
    b := make([]byte, n)
    // A rand.Int63() generates 63 random bits, enough for letterIdMax letters!
    for i, cache, remain := n-1, rand.Int63(), letterIdMax; i >= 0; {
        if remain == 0 {
            cache, remain = rand.Int63(), letterIdMax
        }
        if idx := int(cache & letterIdMask); idx < len(letters) {
            b[i] = letters[idx]
            i--
        }
        cache >>= letterIdBits
        remain--
    }
    return string(b)
}

func TestApproach5(t *testing.T) {
    rand.Seed(time.Now().UnixNano())

    fmt.Println(randStr(10))
}

func BenchmarkApproach5(b *testing.B) {
    rand.Seed(time.Now().UnixNano())
    for i := 0; i < b.N; i++ {
        _ = randStr(10)
    }
}

6. Source

第5個方案非常好，能改進的點并不多。我們可以但不值得搞得很復雜。

讓我們來找可以改進的點：隨機數(shù)的生成源

crypto/rand的包提供了Read(b []byte)的函數(shù)，可以通過這個函數(shù)獲得需要的隨機比特數(shù)，只需要一次調(diào)用。不過并不能提升性能，因為crypto/rand實現(xiàn)了一個密碼學上的安全偽隨機數(shù)，所以速度比較慢。

所以讓我們堅持使用math/rand包，rand.Rand使用rand.Source作為隨機位的來源，rand.Source是一個聲明了Int63() int64的接口：正是我們在最新解決方案中需要和使用的唯一方法。

所以我們不是真的需要rand.Rand，rand.Source包對于我們來說已經(jīng)足夠了

package approach6

import (
    "fmt"
    "math/rand"
    "testing"
    "time"
)

const letters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"

var src = rand.NewSource(time.Now().UnixNano())

const (
    // 6 bits to represent a letter index
    letterIdBits = 6
    // All 1-bits as many as letterIdBits
    letterIdMask = 1<<letterIdBits - 1
    letterIdMax  = 63 / letterIdBits
)

func randStr(n int) string {
    b := make([]byte, n)
    // A rand.Int63() generates 63 random bits, enough for letterIdMax letters!
    for i, cache, remain := n-1, src.Int63(), letterIdMax; i >= 0; {
        if remain == 0 {
            cache, remain = src.Int63(), letterIdMax
        }
        if idx := int(cache & letterIdMask); idx < len(letters) {
            b[i] = letters[idx]
            i--
        }
        cache >>= letterIdBits
        remain--
    }
    return string(b)
}

func TestApproach6(t *testing.T) {
    fmt.Println(randStr(10))
}

func BenchmarkApproach6(b *testing.B) {
    for i := 0; i < b.N; i++ {
        _ = randStr(10)
    }
}

注意到這里我們沒有使用種子初始化rand了，取而代之的是初始化了rand.Source

還有一件需要注意的事，math/rand的文檔指出

默認的Source是協(xié)程安全的

所以默認的Source比通過rand.NewSource()創(chuàng)建出來的Source要慢。不用處理協(xié)程并發(fā)場景，當然慢啦。

7. 使用 strings.Builder

之前的解決方案都返回了通過slice構(gòu)造的字符串。最后的一次轉(zhuǎn)換進行了一次拷貝，因為字符串是不可變的，如果轉(zhuǎn)換的時候不進行拷貝，就無法保證轉(zhuǎn)換完成之后，byte slice再被修改后，字符串仍能保持不變。

Go1.10引入了strings.Builder，這是一個新的類型，和bytes.Buffer類似，用來構(gòu)造字符串。底層使用[]byte來構(gòu)造內(nèi)容，正是我們現(xiàn)在在做的，最后可以通過Builder.String()方法來獲得最終的字符串值。但它很酷的地方在于，它無需執(zhí)行剛才談到的復制即可完成此操作。它敢這么做是因為它底層構(gòu)造的[]byte從未暴露出來，所以仍然可以保證沒有人可以無意地、惡意地來修改已經(jīng)生成的不可變字符串。

所以我們的下一個想法不是在slice中構(gòu)建隨機字符串，而是使用 strings.Builder，結(jié)束building后，我們就可以獲取并返回結(jié)果，而無需復制。這可能在速度方面有所幫助，并且在內(nèi)存使用和分配方面肯定會有所幫助（譯者注：等會在benchmark中會清晰地看到）。

package approach7

import (
    "fmt"
    "math/rand"
    "strings"
    "testing"
    "time"
)

const letters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"

var src = rand.NewSource(time.Now().UnixNano())

const (
    // 6 bits to represent a letter index
    letterIdBits = 6
    // All 1-bits as many as letterIdBits
    letterIdMask = 1<<letterIdBits - 1
    letterIdMax  = 63 / letterIdBits
)

func randStr(n int) string {
    sb := strings.Builder{}
    sb.Grow(n)
    // A rand.Int63() generates 63 random bits, enough for letterIdMax letters!
    for i, cache, remain := n-1, src.Int63(), letterIdMax; i >= 0; {
        if remain == 0 {
            cache, remain = src.Int63(), letterIdMax
        }
        if idx := int(cache & letterIdMask); idx < len(letters) {
            sb.WriteByte(letters[idx])
            i--
        }
        cache >>= letterIdBits
        remain--
    }
    return sb.String()
}

func TestApproach7(t *testing.T) {
    fmt.Println(randStr(10))
}

func BenchmarkApproach7(b *testing.B) {
    for i := 0; i < b.N; i++ {
        _ = randStr(10)
    }
}

在構(gòu)造出builder之后，我們立刻調(diào)用了Builder.Grow()方法，使得它分配一個足夠大的底層slice,避免在后續(xù)操作中再進行分配

8. “Mimicing” strings.Builder with package unsafe

模仿string.Builder使用unsafe包

string.Builder跟我們第六節(jié)地解法一樣，都是用[]byte來構(gòu)建字符串。切換到strings.Builder可能有一些太重了，我們使用strings.Builder只是想避免拷貝slice。

string.Builder使用unsafe包來避免最終的拷貝

// String returns the accumulated string.
func (b *Builder) String() string {
    return *(*string)(unsafe.Pointer(&b.buf))
}

我們也可以自己完成這個流程。所以思路是我們通過unsafe包來返回一個字符串，來避免拷貝

package approach8

import (
    "fmt"
    "math/rand"
    "testing"
    "time"
    "unsafe"
)

const letters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"

var src = rand.NewSource(time.Now().UnixNano())

const (
    // 6 bits to represent a letter index
    letterIdBits = 6
    // All 1-bits as many as letterIdBits
    letterIdMask = 1<<letterIdBits - 1
    letterIdMax  = 63 / letterIdBits
)

func randStr(n int) string {
    b := make([]byte, n)
    // A rand.Int63() generates 63 random bits, enough for letterIdMax letters!
    for i, cache, remain := n-1, src.Int63(), letterIdMax; i >= 0; {
        if remain == 0 {
            cache, remain = src.Int63(), letterIdMax
        }
        if idx := int(cache & letterIdMask); idx < len(letters) {
            b[i] = letters[idx]
            i--
        }
        cache >>= 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)
    }
}

Benchmark

go test ./... -bench=. -benchmem

原作者測試的數(shù)據(jù)

(譯者注：第三列代表操作一次需要多少納秒)

BenchmarkRunes-4 2000000 723 ns/op 96 B/op 2 allocs/op
BenchmarkBytes-4 3000000 550 ns/op 32 B/op 2 allocs/op
BenchmarkBytesRmndr-4 3000000 438 ns/op 32 B/op 2 allocs/op
BenchmarkBytesMask-4 3000000 534 ns/op 32 B/op 2 allocs/op
BenchmarkBytesMaskImpr-4 10000000 176 ns/op 32 B/op 2 allocs/op
BenchmarkBytesMaskImprSrc-4 10000000 139 ns/op 32 B/op 2 allocs/op
BenchmarkBytesMaskImprSrcSB-4 10000000 134 ns/op 16 B/op 1 allocs/op
BenchmarkBytesMaskImprSrcUnsafe-4 10000000 115 ns/op 16 B/op 1 allocs/op

譯者測試的數(shù)據(jù)

BenchmarkApproach1-12 3849038 299.5 ns/op 64 B/op 2 allocs/op
BenchmarkApproach2-12 5545350 216.4 ns/op 32 B/op 2 allocs/op
BenchmarkApproach3-12 7003654 169.7 ns/op 32 B/op 2 allocs/op
BenchmarkApproach4-12 7164259 168.7 ns/op 32 B/op 2 allocs/op
BenchmarkApproach5-12 13205474 89.06 ns/op 32 B/op 2 allocs/op
BenchmarkApproach6-12 13665636 84.41 ns/op 32 B/op 2 allocs/op
BenchmarkApproach7-12 17213431 70.37 ns/op 16 B/op 1 allocs/op
BenchmarkApproach8-12 19756956 61.41 ns/op 16 B/op 1 allocs/op

現(xiàn)在跑出來的數(shù)據(jù)，相原作者時候，已經(jīng)有了一些變化，不過并不妨礙我們看出來各個方法的趨勢：