在 Go 中生成长随机字符串的最快方法是什么？

Question

喜欢 [a-zA-Z0-9] 字符串：

na1dopW129T0anN28udaZ

或十六进制字符串：

8c6f78ac23b4a7b8c0182d

我指的是 2K 或更多字符。

Answer 1

如果你想生成加密安全的随机字符串，我建议你看看this page。这是一个辅助函数，它从操作系统的随机源中读取 n 随机字节，然后使用这些字节对其进行 base64 编码。请注意，由于 base64，字符串长度会大于 n。

package main

import(
    "crypto/rand"
    "encoding/base64"
    "fmt"
)

func GenerateRandomBytes(n int) ([]byte, error) {
    b := make([]byte, n)
    _, err := rand.Read(b)
    if err != nil {
        return nil, err
    }

    return b, nil
}

func GenerateRandomString(s int) (string, error) {
    b, err := GenerateRandomBytes(s)
    return base64.URLEncoding.EncodeToString(b), err
}

func main() {
    token, _ := GenerateRandomString(32)
    fmt.Println(token)
}

Answer 2

这实际上有点偏向于集合中的前 8 个字符（因为 255 不是 len(alphanum) 的倍数），但这会让你大部分时间到达那里。

import (
    "crypto/rand"
)

func randString(n int) string {
    const alphanum = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
    var bytes = make([]byte, n)
    rand.Read(bytes)
    for i, b := range bytes {
        bytes[i] = alphanum[b % byte(len(alphanum))]
    }
    return string(bytes)
}

Answer 3

这在我的盒子上大约 200MBps。有明显的改进空间。

type randomDataMaker struct {
    src rand.Source
}

func (r *randomDataMaker) Read(p []byte) (n int, err error) {
    for i := range p {
        p[i] = byte(r.src.Int63() & 0xff)
    }
    return len(p), nil
}

您只需使用io.CopyN 来生成您想要的字符串。显然你可以在途中调整字符集或其他任何东西。

这个模型的好处是它只是一个io.Reader，所以你可以用它来制作任何东西。

测试如下：

func BenchmarkRandomDataMaker(b *testing.B) {
    randomSrc := randomDataMaker{rand.NewSource(1028890720402726901)}
    for i := 0; i < b.N; i++ {
        b.SetBytes(int64(i))
        _, err := io.CopyN(ioutil.Discard, &randomSrc, int64(i))
        if err != nil {
            b.Fatalf("Error copying at %v: %v", i, err)
        }
    }
}

在我的 2.2GHz i7 的一个核心上：

BenchmarkRandomDataMaker       50000        246512 ns/op     202.83 MB/s

编辑

自从我编写了基准测试后，我想我会做明显的改进（减少随机调用的频率）。使用 1/8 的 rand 调用，它的运行速度提高了大约 4 倍，尽管它更丑：

新版本：

func (r *randomDataMaker) Read(p []byte) (n int, err error) {
    todo := len(p)
    offset := 0
    for {
        val := int64(r.src.Int63())
        for i := 0; i < 8; i++ {
            p[offset] = byte(val & 0xff)
            todo--
            if todo == 0 {
                return len(p), nil
            }
            offset++
            val >>= 8
        }
    }

    panic("unreachable")
}

新基准：

BenchmarkRandomDataMaker      200000        251148 ns/op     796.34 MB/s

编辑 2

去掉了强制转换为字节的掩码，因为它是多余的。更快地获得一笔好交易：

BenchmarkRandomDataMaker      200000        231843 ns/op     862.64 MB/s

（这比实际工作要容易得多sigh）

编辑 3

这是今天在 irc 中出现的，所以我发布了一个库。此外，我的实际基准测试工具虽然对相对速度很有用，但它的报告不够准确。

我创建了randbo，您可以在任何需要的地方重复使用它来生成随机流。

Answer 4

您可以使用 Go 包 uniuri 生成随机字符串（或查看源代码以了解他们是如何做到的）。你会想要使用：

func NewLen(length int) string

NewLen 返回一个新的随机字符串，由标准字符组成。

或者，指定使用的字符集：

func NewLenChars(length int, chars []byte) string

Answer 5

在这里，Evan Shaw 的答案重新工作，没有偏向字符串的前 8 个字符。请注意，它使用了大量昂贵的big.Int 操作，所以可能没那么快！答案是加密强大。

它使用rand.Int 生成一个大小正好合适的整数len(alphanum) ** n，然后进行有效的基本转换为基本len(alphanum)。

几乎可以肯定有一个更好的算法来解决这个问题，它需要保留一个小得多的余数并在必要时向其中添加随机字节。这将摆脱昂贵的长整数运算。

import (
    "crypto/rand"
    "fmt"
    "math/big"
)

func randString(n int) string {
    const alphanum = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
    symbols := big.NewInt(int64(len(alphanum)))
    states := big.NewInt(0)
    states.Exp(symbols, big.NewInt(int64(n)), nil)
    r, err := rand.Int(rand.Reader, states)
    if err != nil {
        panic(err)
    }
    var bytes = make([]byte, n)
    r2 := big.NewInt(0)
    symbol := big.NewInt(0)
    for i := range bytes {
        r2.DivMod(r, symbols, symbol)
        r, r2 = r2, r
        bytes[i] = alphanum[symbol.Int64()]
    }
    return string(bytes)
}