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

Problem

I want a random string of characters only (uppercase or lowercase), no numbers, in Go. What is the fastest and simplest way to do this?

Answer

The question seeks the "fastest and simplest" approach. Paul's response offers a straightforward technique. However, let's also consider the "fastest" aspect. We'll refine our code iteratively, arriving at an optimized solution.

I. Improvements

1. Genesis (Runes)

The initial solution we'll optimize is:

import (
    "math/rand"
    "time"
)

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. Bytes

If the characters used for the random string are restricted to uppercase and lowercase English alphabets, we can work with bytes because English alphabet letters map 1-to-1 to bytes in UTF-8 encoding (which Go uses to store strings).

So we can replace:

var letters = []rune("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")

with:

var letters = []byte("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")

Or better yet:

const letters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"

This is a significant improvement because we can now use a const (Go supports string constants but not slice constants). Additionally, the expression len(letters) will also be constant.

3. Remainder

Previous solutions determined a random number for a letter by calling rand.Intn() (which delegates to Rand.Intn() and further to Rand.Int31n()).

This is slower than using rand.Int63() which produces a random number with 63 random bits.

So we can simply call rand.Int63() and use the remainder after dividing by len(letters):

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

This is faster while maintaining an equal probability distribution of all letters (although the distortion is negligible, the number of letters 52 is much smaller than 1

4. Masking

We can maintain an equal distribution of letters by using only the lowest bits of the random number, enough to represent the number of letters. For 52 letters, 6 bits are required: 52 = 110100b. So we'll only use the lowest 6 bits of the number returned by rand.Int63().

We also only "accept" the number if it falls within the range 0..len(letterBytes)-1. If the lowest bits are larger, we discard and request a new number.

const (
    letterIdxBits = 6                    // 6 bits to represent a letter index
    letterIdxMask = 1
5. Masking Improved
The previous solution only uses the lowest 6 bits of the 63 random bits from rand.Int63(). This is inefficient as obtaining the random bits is the slowest part of our algorithm.
Since we have 52 letters, 6 bits code a letter index. The 63 random bits can designate 63/6 = 10 different letter indices. Let's use all 10:
const (
    letterIdxBits = 6                    // 6 bits to represent a letter index
    letterIdxMask = 1= 0; {
        if remain == 0 {
            cache, remain = rand.Int63(), letterIdxMax
        }
        if idx := int(cache & letterIdxMask); idx >= letterIdxBits
        remain--
    }
    return string(b)
}
6. Source
Masking Improved is quite efficient. Let's consider another aspect: the source of random numbers.
The crypto/rand package provides the function Read(b []byte). However, this wouldn't help performance because crypto/rand implements a cryptographically secure pseudorandom number generator, which is slower.
So we'll stick to the math/rand package. rand.Rand uses a rand.Source as the source of random bits. So we can use a rand.Source directly:
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 >= letterIdxBits
        remain--
    }
    return string(b)
}
7. Utilizing strings.Builder
Previous solutions returned strings constructed first in a slice ([]rune in Genesis and []byte subsequently) and then converted to string. This final conversion requires copying the slice content because string values are immutable.
Go 1.10 introduced strings.Builder. This new type can be used to build string contents similarly to bytes.Buffer. It uses a []byte internally and doesn't need to copy the content to produce the string.
func RandStringBytesMaskImprSrcSB(n int) string {
    sb := strings.Builder{}
    sb.Grow(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 >= letterIdxBits
        remain--
    }
    return sb.String()
}
8. "Mimicking" strings.Builder with package unsafe
strings.Builder builds a string in an internal []byte, just like we did ourselves. So using strings.Builder introduces some overhead, which we only switched to avoid the final copying.
However, we can also avoid this copying by using package unsafe:
func RandStringBytesMaskImprSrcUnsafe(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