8種超簡(jiǎn)單的Golang生成隨機(jī)字符串方式分享
前言
這是icza在StackOverflow上的一篇高贊回答，質(zhì)量很高，翻譯一下，大家一起學(xué)習(xí)
問題是：go語言中，有沒有什么最快最簡(jiǎn)單的方法，用來生成只包含英文字母的隨機(jī)字符串
icza給出了8個(gè)方案，最簡(jiǎn)單的方法并不是最快的方法，它們各有優(yōu)劣，末尾附上性能測(cè)試結(jié)果：
1. Runes
比較簡(jiǎn)單的答案，聲明一個(gè)rune數(shù)組，通過隨機(jī)數(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
如果隨機(jī)挑選的字符只包含英文字母，我們可以直接使用bytes，因?yàn)樵赨TF-8編碼模式下，英文字符和Bytes是一對(duì)一的（Go正是使用UTF-8模式編碼）
所以可以把
var letters = []rune("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")用這個(gè)替代
var letters = []byte("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")或者更好
const letters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
現(xiàn)在我們有很大的進(jìn)展了，我們把它變?yōu)榱艘粋€(gè)常數(shù)，在go里面，只有string常數(shù)，可并沒有slice常數(shù)。額外的收獲，表達(dá)式len(letters)也變?yōu)榱艘粋€(gè)常數(shù)（如果s為常數(shù)，那么len(s)也將是常數(shù))
我們沒有付出什么代碼，現(xiàn)在letters可以通過下標(biāo)訪問其中的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()來獲得一個(gè)隨機(jī)字母，這個(gè)方法底層調(diào)用了Rand.Intn()，然后調(diào)用了Rand.Int31n()
相比于生成63個(gè)隨機(jī)bits的函數(shù)rand.Int63()來說，Rand.Int31n()很慢。
我們可以簡(jiǎn)單地調(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)
}
}這個(gè)算法能正常工作并且非?？?，不過它犧牲了部分精確性，字母出現(xiàn)的概率并不是精確一樣的（假設(shè)rand.Int63()生成63比特的數(shù)字是等概率的）。由于字母總共才52個(gè)，遠(yuǎn)小于 1<<63 - 1，因此失真非常小，因此實(shí)際上這完全沒問題。
解釋: 假設(shè)你想要0~5的隨機(jī)數(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)在接近了一些了，是吧？不斷地增加比特位，這個(gè)差距就會(huì)變得越小，當(dāng)你有63位地時(shí)候，這差別已經(jīng)可忽略不計(jì)。
4. Masking 掩碼
在上一個(gè)方案的基礎(chǔ)上，我們通過僅使用隨機(jī)數(shù)的最低n位保持均勻分布，n表示所有字符的數(shù)量。比如我們有52個(gè)字母，我們需要6位（52 = 110100b）。所以我們僅僅使用了rand.Int63()的最后6位。并且，為了保持所有字符的均勻分布，我們決定只接受在0..len(letterBytes)-1的數(shù)字即0~51。（譯者注：這里已經(jīng)沒有第三個(gè)方案的不準(zhǔn)確問題了）
最低幾位大于等于len(letterBytes)的概率一般小于0.5（平均值為0.25），這意味著出現(xiàn)這種情況，只要重試就好。重試n次之后，我們?nèi)匀恍枰獊G棄這個(gè)數(shù)字的概率遠(yuǎn)小于0.5的n次方（這是上界了，實(shí)際會(huì)低于這個(gè)值）。以本文的52個(gè)字母為例，最低6位需要丟棄的概率只有(64-52)/64=0.19。這意味著，重復(fù)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個(gè)隨機(jī)字節(jié)的后6位。這實(shí)在是太浪費(fèi)了，因?yàn)?code>rand.Int63()是我們算法中最耗時(shí)的部分了。
如果我們有52個(gè)字母，6位就能生成一個(gè)隨機(jī)字符串。所以63個(gè)隨機(jī)字節(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個(gè)方案非常好，能改進(jìn)的點(diǎn)并不多。我們可以但不值得搞得很復(fù)雜。
讓我們來找可以改進(jìn)的點(diǎn)：隨機(jī)數(shù)的生成源
crypto/rand的包提供了Read(b []byte)的函數(shù)，可以通過這個(gè)函數(shù)獲得需要的隨機(jī)比特?cái)?shù)，只需要一次調(diào)用。不過并不能提升性能，因?yàn)?code>crypto/rand實(shí)現(xiàn)了一個(gè)密碼學(xué)上的安全偽隨機(jī)數(shù)，所以速度比較慢。
所以讓我們堅(jiān)持使用math/rand包，rand.Rand使用rand.Source作為隨機(jī)位的來源，rand.Source是一個(gè)聲明了Int63() int64的接口：正是我們?cè)谧钚陆鉀Q方案中需要和使用的唯一方法。
所以我們不是真的需要rand.Rand，rand.Source包對(duì)于我們來說已經(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的文檔指出
默認(rèn)的Source是協(xié)程安全的
所以默認(rèn)的Source比通過rand.NewSource()創(chuàng)建出來的Source要慢。不用處理協(xié)程并發(fā)場(chǎng)景，當(dāng)然慢啦。
7. 使用 strings.Builder
之前的解決方案都返回了通過slice構(gòu)造的字符串。最后的一次轉(zhuǎn)換進(jìn)行了一次拷貝，因?yàn)樽址遣豢勺兊?，如果轉(zhuǎn)換的時(shí)候不進(jìn)行拷貝，就無法保證轉(zhuǎn)換完成之后，byte slice再被修改后，字符串仍能保持不變。
Go1.10引入了strings.Builder，這是一個(gè)新的類型，和bytes.Buffer類似，用來構(gòu)造字符串。底層使用[]byte來構(gòu)造內(nèi)容，正是我們現(xiàn)在在做的，最后可以通過Builder.String()方法來獲得最終的字符串值。但它很酷的地方在于，它無需執(zhí)行剛才談到的復(fù)制即可完成此操作。它敢這么做是因?yàn)樗讓訕?gòu)造的[]byte從未暴露出來，所以仍然可以保證沒有人可以無意地、惡意地來修改已經(jīng)生成的不可變字符串。
所以我們的下一個(gè)想法不是在slice中構(gòu)建隨機(jī)字符串，而是使用 strings.Builder，結(jié)束building后，我們就可以獲取并返回結(jié)果，而無需復(fù)制。 這可能在速度方面有所幫助，并且在內(nèi)存使用和分配方面肯定會(huì)有所幫助（譯者注：等會(huì)在benchmark中會(huì)清晰地看到）。
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()方法，使得它分配一個(gè)足夠大的底層slice,避免在后續(xù)操作中再進(jìn)行分配
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))
}我們也可以自己完成這個(gè)流程。所以思路是我們通過unsafe包來返回一個(gè)字符串，來避免拷貝
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
原作者測(cè)試的數(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
譯者測(cè)試的數(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ù)，相原作者時(shí)候，已經(jīng)有了一些變化，不過并不妨礙我們看出來各個(gè)方法的趨勢(shì)：
- 僅僅只是把rune切換到byte，就獲得了性能的大幅度提升(大于百分之20)
- 使用
rand.Int63()代替rand.Intn()也獲得大幅度提升(大于百分之20) - 使用Masking并沒有提升性能，相反在原作者哪里，反而性能下降了
- 不過使用了一次
rand.Int63()返回的全部字符后，性能提升了3倍 - 使用
rand.Source替代rand.Rand，性能提升了21% - 使用
strings.Builder，我們?cè)谒俣壬咸嵘?.5%，并且把原本2次的內(nèi)存分配，降低到了一次！ - 使用
unsafe包來代替strings.Builder，性能提升了14%
將第八個(gè)方案和第一個(gè)方案比較，第八個(gè)方案比第一個(gè)方案快6.3倍，僅僅使用六分之一的內(nèi)存，分配次數(shù)也只有原來的一半。
到此這篇關(guān)于8種超簡(jiǎn)單的Golang生成隨機(jī)字符串方式分享的文章就介紹到這了,更多相關(guān)Go生成隨機(jī)字符串內(nèi)容請(qǐng)搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！
相關(guān)文章
go?singleflight緩存雪崩源碼分析與應(yīng)用
這篇文章主要為大家介紹了go?singleflight緩存雪崩源碼分析與應(yīng)用示例詳解，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進(jìn)步，早日升職加薪2023-09-09
golang模板template自定義函數(shù)用法示例
這篇文章主要介紹了golang模板template自定義函數(shù)用法,結(jié)合實(shí)例形式分析了Go語言模板自定義函數(shù)的基本定義與使用方法,需要的朋友可以參考下2016-07-07
這篇文章主要介紹了GoLang函數(shù)棧的使用，我們的代碼會(huì)被編譯成機(jī)器指令并寫入到可執(zhí)行文件，當(dāng)程序執(zhí)行時(shí)，可執(zhí)行文件被加載到內(nèi)存，這些機(jī)器指令會(huì)被存儲(chǔ)到虛擬地址空間中的代碼段，在代碼段內(nèi)部，指令是低地址向高地址堆積的2023-02-02
這篇文章主要介紹了Go日常開發(fā)常用第三方庫(kù)和工具介紹,主要有web開發(fā)、數(shù)據(jù)庫(kù)開發(fā)、Redis開發(fā)需要的朋友可以參考下2022-11-11
使用Go語言開發(fā)自動(dòng)化API測(cè)試工具詳解
這篇文章主要為大家詳細(xì)介紹了如何使用Go語言開發(fā)自動(dòng)化API測(cè)試工具,文中的示例代碼講解詳細(xì),具有一定的借鑒價(jià)值,有需要的小伙伴可以參考下2024-03-03
golang 一次性定時(shí)器Timer用法及實(shí)現(xiàn)原理詳解
