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)的概率并不是精確一樣的（假設rand.Int63()生成63比特的數(shù)字是等概率的）。由于字母總共才52個，遠小于 1<<63 - 1，因此失真非常小，因此實際上這完全沒問題。
解釋: 假設你想要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?，F(xiàn)在接近了一些了，是吧？不斷地增加比特位，這個差距就會變得越小，當你有63位地時候，這差別已經(jīng)可忽略不計。
4. Masking 掩碼
在上一個方案的基礎上，我們通過僅使用隨機數(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)有了一些變化，不過并不妨礙我們看出來各個方法的趨勢：
- 僅僅只是把rune切換到byte，就獲得了性能的大幅度提升(大于百分之20)
- 使用
rand.Int63()代替rand.Intn()也獲得大幅度提升(大于百分之20) - 使用Masking并沒有提升性能，相反在原作者哪里，反而性能下降了
- 不過使用了一次
rand.Int63()返回的全部字符后，性能提升了3倍 - 使用
rand.Source替代rand.Rand，性能提升了21% - 使用
strings.Builder，我們在速度上提升了3.5%，并且把原本2次的內(nèi)存分配，降低到了一次！ - 使用
unsafe包來代替strings.Builder，性能提升了14%
將第八個方案和第一個方案比較，第八個方案比第一個方案快6.3倍，僅僅使用六分之一的內(nèi)存，分配次數(shù)也只有原來的一半。
到此這篇關于8種超簡單的Golang生成隨機字符串方式分享的文章就介紹到這了,更多相關Go生成隨機字符串內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！
相關文章
這篇文章主要介紹了go語言實現(xiàn)猜數(shù)字小游戲的方法,實例分析了Go語言流程判斷與處理的技巧,需要的朋友可以參考下2015-03-03
Go語言高效I/O并發(fā)處理雙緩沖和Exchanger模式實例探索
這篇文章主要介紹了Go語言高效I/O并發(fā)處理雙緩沖和Exchanger模式實例探索,有需要的朋友可以借鑒參考下,希望能夠有所幫助,祝大家多多進步,早日升職加薪2024-01-01
使用golang引入外部包的三種方式:go get, go module, ve
這篇文章主要介紹了使用golang引入外部包的三種方式:go get, go module, vendor目錄,具有很好的參考價值,希望對大家有所幫助,如有錯誤或未考慮完全的地方,望不吝賜教2024-01-01
這篇文章主要介紹了Go中runtime.Caller的使用,本文給大家介紹的非常詳細,對大家的學習或工作具有一定的參考借鑒價值,需要的朋友參考下吧2024-03-03
go-redis Pipeline與事務的實現(xiàn)示例
本文介紹了Go-Redis v9中Pipeline、事務和Watch機制的使用方法與優(yōu)化實踐,文中通過示例代碼介紹的非常詳細,對大家的學習或者工作具有一定的參考學習價值,需要的朋友們下面隨著小編來一起學習學習吧2025-11-11
Excelize是一個用純Go語言編寫的庫，提供了一組函數(shù)，可以對XLAM?/?XLSM?/?XLSX?/?XLTM?/?XLTX文件進行讀寫。支持讀寫由Microsoft?Excel?2007及以后版本生成的電子表格文檔。本文就將用它實現(xiàn)讀寫Excel文件操作，感興趣的可以學習一下2022-11-11
本文介紹了在基于gin框架開發(fā)的項目中如何配置并使用zap來接收并記錄gin框架默認的日志和如何配置日志歸檔。有需要的朋友可以借鑒參考下，希望能夠有所幫助2022-04-04
Go語言sync.Map實現(xiàn)高并發(fā)場景下的安全映射
當我們面對高并發(fā)場景時,使用普通的map類型會遇到棘手的并發(fā)安全問題,下面就來介紹一下Go語言sync.Map實現(xiàn)高并發(fā)場景下的安全映射,具有一定的參考價值,感興趣的可以了解一下2025-05-05
這篇文章主要為大家介紹了GO語言基礎入門的第一個go程序解讀，下面來帶大家進入Go語言世界helloworld的大門吧，有需要的朋友可以借鑒參考下，希望能夠有所幫助2021-11-11
go new和make的區(qū)別以及為什么new返回的是指針問題分析
Go語言中new和make的區(qū)別在于：new用于分配值類型內(nèi)存并返回指針,適用于所有值類型；make用于創(chuàng)建并初始化slice、map和channel,只適用于引用類型,new返回指針可以明確表示值是在堆上分配的,避免不必要的值拷貝,并且與零值初始化語義一致2026-01-01