如果想在Go语言中生成只有随机字符(大写或小写)、没有数字的定长字符串。什么方法最快最简单？

这个问题要求“最快最简单的方法”。我们将由浅入深，以循序渐进的方式给出最终最快的代码。（可以在答案的最后找到每次迭代的基准测试。）

所有解决方案和基准测试代码都可以在Go Playground上找到。 Playground上的代码是测试文件，而不是可执行文件。将其保存到名为XX_test.go的文件中，并使用go test -bench .可以运行它。

一，逐步改进的方法

1.起步(字符)

我们需要改进的原始通用解决方案是：

func init() {
    rand.Seed(time.Now().UnixNano())
}

var letterRunes = []rune("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")

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

2.字节

如果要选择和汇总的字符来自随机字符串（只包含英文字母的大写和小写字母），我们可以使用字节，因为英文字母映射到UTF-8编码中的字节是1对1(是如何存储字符串)。

所以代替：

var letters = []rune("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")

我们可以用：

var letters = []bytes("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")

甚至更好的：

const letters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"

现在这已经是一个很大的改进：我们可以将它变为const(有string常量，但是没有slice常量)。作为额外的收益，表达式len(letters)也将是const！ (如果s是一个字符串常量，则表达式len(s)是常量。)

这样的性能开销是多少？几乎没有开销！ string可以编入索引，索引其字节。完美，正是我们想要的。

所以我们的下一个方法如下：

const letterBytes = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"

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

3.求余数

之前的解决方案通过调用Rand.Intn()获得一个随机数来指定随机字母，rand.Intn()委托给Rand.Int31n()。

与rand.Int63()相比，这要慢得多，后者产生一个63随机bits的随机数。

所以我们可以简单地调用rand.Int63()并在除以len(letterBytes)后使用余数：

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

这种方法效果明显更快，缺点是所有字母的概率都不完全相同(假设rand.Int63()以相同的概率产生所有63位数字)。尽管由于字母52的数量比1<<63 - 1小很多，但是失真非常小，所以在实践中这非常精细。

为了使这个理解更容易：假设你想要一个0..5范围内的随机数。使用3个随机位，这将产生具有双倍概率的数字0..1，而不是来自范围2..5。使用5个随机位，0..1范围内的数字将与6/32概率和2..5范围内的数字一起出现，其中5/32概率现在更接近期望值。增加位数会使这一点变得不那么重要，当达到63位时，它可以忽略不计。

4.掩码

在前面的解决方案的基础上，我们可以通过使用随机数的最低位来保证字母的平等分配。因此，例如，如果我们有52个字母，则需要6位来表示它：52 = 110100b。所以我们只使用rand.Int63()返回的最低6位数。并且为了保持字母的平均分配，我们只有”接受”落在0..len(letterBytes)-1的范围内的数字。如果最低位更大，我们将其丢弃并查询新的随机数。

请注意，最低位大于或等于len(letterBytes)的可能性一般小于0.5(平均为0.25)，这意味着即使出现这种情况，重复此”rare”案例也会降低找不到的好的数字的可能性。在n次重复之后，我们没有获得好数字的机会远小于pow(0.5, n)，这只是一个较高的估计。在52个字母的情况下，6个最低位不好的可能性仅为(64-52)/64 = 0.19;这意味着例如在10次重复之后没有良好数字的机会是1e-8。

所以新的解决方案如下：

const letterBytes = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
const (
    letterIdxBits = 6                    // 6 bits to represent a letter index
    letterIdxMask = 1<<letterIdxBits - 1 // All 1-bits, as many as letterIdxBits
)

func RandStringBytesMask(n int) string {
    b := make([]byte, n)
    for i := 0; i < n; {
        if idx := int(rand.Int63() & letterIdxMask); idx < len(letterBytes) {
            b[i] = letterBytes[idx]
            i++
        }
    }
    return string(b)
}

5.掩码改进

前面的解决方案仅使用rand.Int63()返回的63个随机位中的最低6位。这是一种浪费，因为获取随机位是我们算法中最慢的部分。

如果我们有52个字母，那意味着6bits编码字母索引。所以63个随机位可以指定63/6 = 10不同的字母索引。让我们使用所有这10个：

const letterBytes = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
const (
    letterIdxBits = 6                    // 6 bits to represent a letter index
    letterIdxMask = 1<<letterIdxBits - 1 // All 1-bits, as many as letterIdxBits
    letterIdxMax  = 63 / letterIdxBits   // # of letter indices fitting in 63 bits
)

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

    return string(b)
}

6.来源

掩码改进非常好，我们还可以改进它，但过于复杂以至于不值得这么做了。

现在让我们找到其他改进的点——看看随机数的来源。

有一个crypto/rand包提供了一个Read(b []byte)函数，所以我们可以用它来获得我们需要的单个调用所需的字节数。这在性能方面没有帮助，因为crypto/rand实现了加密安全的伪随机数生成器，因此速度要慢得多。

让我们坚持使用math/rand软件包。 rand.Rand使用rand.Source作为随机位的来源。 rand.Source是一个指定Int63() int64方法的接口：我们最新解决方案中唯一需要和使用的方法。

所以我们真的不需要rand.Rand(显式或全局，共享的rand包)，rand.Source对我们来说已经足够了：

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

func RandStringBytesMaskImprSrc(n int) string {
    b := make([]byte, n)
    // A src.Int63() generates 63 random bits, enough for letterIdxMax characters!
    for i, cache, remain := n-1, src.Int63(), letterIdxMax; i >= 0; {
        if remain == 0 {
            cache, remain = src.Int63(), letterIdxMax
        }
        if idx := int(cache & letterIdxMask); idx < len(letterBytes) {
            b[i] = letterBytes[idx]
            i--
        }
        cache >>= letterIdxBits
        remain--
    }

    return string(b)
}

另请注意，最后一个解决方案不要求您初始化(播种)math/rand软件包的全局Rand，因为它未被使用(并且我们的rand.Source已正确初始化/设置种子)。

还有一点需要注意：math/rand的包文档说明：

The default Source is safe for concurrent use by multiple goroutines.

所以默认源比rand.NewSource()可能获得的Source慢，因为默认源必须在并发访问/使用时提供安全性，而rand.NewSource()不提供此功能(因此它返回的Source可以更快) )。

二、评测

好吧，让我们对不同的解决方案进行基准测试。

BenchmarkRunes                   1000000              1703 ns/op
BenchmarkBytes                   1000000              1328 ns/op
BenchmarkBytesRmndr              1000000              1012 ns/op
BenchmarkBytesMask               1000000              1214 ns/op
BenchmarkBytesMaskImpr           5000000               395 ns/op
BenchmarkBytesMaskImprSrc        5000000               303 ns/op

只需从字符串切换到字节，我们立即获得22％的性能提升。

摆脱rand.Intn()并使用rand.Int63()代替另外24％的提升。

掩码(并且在大索引的情况下重复)减慢一点(由于重复调用)：-20％……

但是当我们使用63个随机位中的所有(或大多数)(来自一个rand.Int63()调用的10个索引)时：它加速了3.4倍。

最后，如果我们解决了(non-default，新)rand.Source代替rand.Rand，我们再次获得23％。

比较最终解决方案：RandStringBytesMaskImprSrc()比RandStringRunes()快5.6倍。

参考资料

• How to generate a random string of a fixed length in Go?