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

Question

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

User · Answer

Here is a simple and performant solution for a cryptographically secure random string.

package main

import (
    "crypto/rand"
    "unsafe"
    "fmt"
)

var alphabet = []byte("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")

func main() {
    fmt.Println(generate(16))
}

func generate(size int) string {
    b := make([]byte, size)
    rand.Read(b)
    for i := 0; i < size; i++ {
        b[i] = alphabet[b[i] / 5]
    }
    return *(*string)(unsafe.Pointer(&b))
}

Benchmark

Benchmark  95.2 ns/op      16 B/op      1 allocs/op

User · Answer

korzhao     package rand  import       crand  crypto rand       math rand       sync       time       unsafe        Doesn t share the rand library globally  reducing lock contention type Rand struct       Seed int64     Pool  sync Pool    var       MRand      NewRand       randlist     byte  abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890         init random number generator func NewRand    Rand       p     amp sync Pool New  func   interface             return rand New rand NewSource getSeed                      mrand     amp Rand          Pool  p            return mrand       get the seed func getSeed   int64       return time Now   UnixNano      func  s  Rand  getrand    rand Rand       return s Pool Get     rand Rand    func  s  Rand  putrand r  rand Rand        s Pool Put r        get a random number func  s  Rand  Intn n int  int       r    s getrand       defer s putrand r       return r Intn n         bulk get random numbers func  s  Rand  Read p   byte   int  error        r    s getrand       defer s putrand r       return r Read p     func CreateRandomString len int  string       b    make   byte  len         err    MRand Read b      if err    nil           return              for i    0  i  lt  len  i             b i    randlist b i   62             return    string  unsafe Pointer  amp b       24 0 ns op            16 B op          1 allocs

User · Answer

const       chars          0123456789 abcdefghijkl-mnopqrstuvwxyz    ABCDEFGHIJKLMNOPQRSTUVWXYZ     charsLen      len chars      mask          1 lt  lt 6 - 1    var rng   rand NewSource time Now   UnixNano        RandStr              func RandStr ln int  string          chars 38           rng Int63       64bit           6bit 2 6 64      10              buf    make   byte  ln      for idx  cache  remain    ln-1  rng Int63    10  idx  gt   0            if remain    0               cache  remain   rng Int63    10                   buf idx    chars int cache amp mask  charsLen          cache  gt  gt   6         remain--         idx--           return    string  unsafe Pointer  amp buf       BenchmarkRandStr16-8    20000000            68 1 ns op        16 B op          1 allocs op

User · Answer

Paul s solution provides a simple  general solution  The question asks for the  quot the fastest and simplest way quot   Let s address the fastest part too  We ll arrive at our final  fastest code in an iterative manner  Benchmarking each iteration can be found at the end of the answer  All the solutions and the benchmarking code can be found on the Go Playground  The code on the Playground is a test file  not an executable  You have to save it into a file named XX test go and run it with go test -bench   -benchmem  Foreword   The fastest solution is not a go-to solution if you just need a random string  For that  Paul s solution is perfect  This is if performance does matter  Although the first 2 steps  Bytes and Remainder  might be an acceptable compromise  they do improve performance by like 50   see exact numbers in the II  Benchmark section   and they don t increase complexity significantly   Having said that  even if you don t need the fastest solution  reading through this answer might be adventurous and educational  I  Improvements 1  Genesis  Runes  As a reminder  the original  general solution we re improving is this  func init         rand Seed time Now   UnixNano       var letterRunes     rune  quot abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ quot    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 to choose from and assemble the random string contains only the uppercase and lowercase letters of the English alphabet  we can work with bytes only because the English alphabet letters map to bytes 1-to-1 in the UTF-8 encoding  which is how Go stores strings   So instead of  var letters     rune  quot abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ quot    we can use  var letters     bytes  quot abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ quot    Or even better  const letters    quot abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ quot   Now this is already a big improvement  we could achieve it to be a const  there are string constants but there are no slice constants   As an extra gain  the expression len letters  will also be a const   The expression len s  is constant if s is a string constant   And at what cost  Nothing at all  strings can be indexed which indexes its bytes  perfect  exactly what we want  Our next destination looks like this  const letterBytes    quot abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ quot   func RandStringBytes n int  string       b    make   byte  n      for i    range b           b i    letterBytes rand Intn len letterBytes              return string b     3  Remainder Previous solutions get a random number to designate a random letter by calling rand Intn   which delegates to Rand Intn   which delegates to Rand Int31n    This is much slower compared to rand Int63   which produces a random number with 63 random bits  So we could simply call rand Int63   and use the remainder after dividing by 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     This works and is significantly faster  the disadvantage is that the probability of all the letters will not be exactly the same  assuming rand Int63   produces all 63-bit numbers with equal probability   Although the distortion is extremely small as the number of letters 52 is much-much smaller than 1 lt  lt 63 - 1  so in practice this is perfectly fine  To make this understand easier  let s say you want a random number in the range of 0  5  Using 3 random bits  this would produce the numbers 0  1 with double probability than from the range 2  5  Using 5 random bits  numbers in range 0  1 would occur with 6 32 probability and numbers in range 2  5 with 5 32 probability which is now closer to the desired  Increasing the number of bits makes this less significant  when reaching 63 bits  it is negligible  4  Masking Building on the previous solution  we can maintain the equal distribution of letters by using only as many of the lowest bits of the random number as many is required to represent the number of letters  So for example if we have 52 letters  it requires 6 bits to represent it  52   110100b  So we will only use the lowest 6 bits of the number returned by rand Int63    And to maintain equal distribution of letters  we only  quot accept quot  the number if it falls in the range 0  len letterBytes -1  If the lowest bits are greater  we discard it and query a new random number  Note that the chance of the lowest bits to be greater than or equal to len letterBytes  is less than 0 5 in general  0 25 on average   which means that even if this would be the case  repeating this  quot rare quot  case decreases the chance of not finding a good number  After n repetition  the chance that we still don t have a good index is much less than pow 0 5  n   and this is just an upper estimation  In case of 52 letters the chance that the 6 lowest bits are not good is only  64-52  64   0 19  which means for example that chances to not have a good number after 10 repetition is 1e-8  So here is the solution  const letterBytes    quot abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ quot  const       letterIdxBits   6                       6 bits to represent a letter index     letterIdxMask   1 lt  lt letterIdxBits - 1    All 1-bits  as many as letterIdxBits    func RandStringBytesMask n int  string       b    make   byte  n      for i    0  i  lt  n            if idx    int rand Int63    amp  letterIdxMask   idx  lt  len letterBytes                b i    letterBytes idx              i                       return string b     5  Masking Improved The previous solution only uses the lowest 6 bits of the 63 random bits returned by rand Int63    This is a waste as getting the random bits is the slowest part of our algorithm  If we have 52 letters  that means 6 bits code a letter index  So 63 random bits can designate 63 6   10 different letter indices  Let s use all those 10  const letterBytes    quot abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ quot  const       letterIdxBits   6                       6 bits to represent a letter index     letterIdxMask   1 lt  lt 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  gt   0            if remain    0               cache  remain   rand Int63    letterIdxMax                   if idx    int cache  amp  letterIdxMask   idx  lt  len letterBytes                b i    letterBytes idx              i--                   cache  gt  gt   letterIdxBits         remain--            return string b     6  Source The Masking Improved is pretty good  not much we can improve on it  We could  but not worth the complexity  Now let s find something else to improve  The source of random numbers  There is a crypto rand package which provides a Read b   byte  function  so we could use that to get as many bytes with a single call as many we need  This wouldn t help in terms of performance as crypto rand implements a cryptographically secure pseudorandom number generator so it s much slower  So let s stick to the math rand package  The rand Rand uses a rand Source as the source of random bits  rand Source is an interface which specifies a Int63   int64 method  exactly and the only thing we needed and used in our latest solution  So we don t really need a rand Rand  either explicit or the global  shared one of the rand package   a rand Source is perfectly enough for us  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  gt   0            if remain    0               cache  remain   src Int63    letterIdxMax                   if idx    int cache  amp  letterIdxMask   idx  lt  len letterBytes                b i    letterBytes idx              i--                   cache  gt  gt   letterIdxBits         remain--            return string b     Also note that this last solution doesn t require you to initialize  seed  the global Rand of the math rand package as that is not used  and our rand Source is properly initialized   seeded   One more thing to note here  package doc of math rand states   The default Source is safe for concurrent use by multiple goroutines   So the default source is slower than a Source that may be obtained by rand NewSource    because the default source has to provide safety under concurrent access   use  while rand NewSource   does not offer this  and thus the Source returned by it is more likely to be faster   7  Utilizing strings Builder All previous solutions return a string whose content is first built in a slice    rune in Genesis  and   byte in subsequent solutions   and then converted to string  This final conversion has to make a copy of the slice s content  because string values are immutable  and if the conversion would not make a copy  it could not be guaranteed that the string s content is not modified via its original slice  For details  see How to convert utf8 string to   byte  and golang    byte string  vs   byte  string   Go 1 10 introduced strings Builder  strings Builder is a new type we can use to build contents of a string similar to bytes Buffer  Internally it uses a   byte to build the content  and when we re done  we can obtain the final string value using its Builder String   method  But what s cool in it is that it does this without performing the copy we just talked about above  It dares to do so because the byte slice used to build the string s content is not exposed  so it is guaranteed that no one can modify it unintentionally or maliciously to alter the produced  quot immutable quot  string  So our next idea is to not build the random string in a slice  but with the help of a strings Builder  so once we re done  we can obtain and return the result without having to make a copy of it  This may help in terms of speed  and it will definitely help in terms of memory usage and allocations  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  gt   0            if remain    0               cache  remain   src Int63    letterIdxMax                   if idx    int cache  amp  letterIdxMask   idx  lt  len letterBytes                sb WriteByte letterBytes idx               i--                   cache  gt  gt   letterIdxBits         remain--            return sb String      Do note that after creating a new strings Buidler  we called its Builder Grow   method  making sure it allocates a big-enough internal slice  to avoid reallocations as we add the random letters   8   quot Mimicing quot  strings Builder with package unsafe strings Builder builds the string in an internal   byte  the same as we did ourselves  So basically doing it via a strings Builder has some overhead  the only thing we switched to strings Builder for is to avoid the final copying of the slice  strings Builder avoids the final copy by using package unsafe     String returns the accumulated string  func  b  Builder  String   string       return    string  unsafe Pointer  amp b buf      The thing is  we can also do this ourselves  too  So the idea here is to switch back to building the random string in a   byte  but when we re done  don t convert it to string to return  but do an unsafe conversion  obtain a string which points to our byte slice as the string data  This is how it can be done  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  gt   0            if remain    0               cache  remain   src Int63    letterIdxMax                   if idx    int cache  amp  letterIdxMask   idx  lt  len letterBytes                b i    letterBytes idx              i--                   cache  gt  gt   letterIdxBits         remain--            return    string  unsafe Pointer  amp b       9  Using rand Read    Go 1 7 added a rand Read   function and a Rand Read   method  We should be tempted to use these to read as many bytes as we need in one step  in order to achieve better performance  There is one small  quot problem quot  with this  how many bytes do we need  We could say  as many as the number of output letters  We would think this is an upper estimation  as a letter index uses less than 8 bits  1 byte   But at this point we are already doing worse  as getting the random bits is the  quot hard part quot    and we re getting more than needed  Also note that to maintain equal distribution of all letter indices  there might be some  quot garbage quot  random data that we won t be able to use  so we would end up skipping some data  and thus end up short when we go through all the byte slice  We would need to further get more random bytes   quot recursively quot   And now we re even losing the  quot single call to rand package quot  advantage    We could  quot somewhat quot  optimize the usage of the random data we acquire from math Rand    We may estimate how many bytes  bits  we ll need  1 letter requires letterIdxBits bits  and we need n letters  so we need n   letterIdxBits   8 0 bytes rounding up  We can calculate the probability of a random index not being usable  see above   so we could request more that will  quot more likely quot  be enough  if it turns out it s not  we repeat the process   We can process the byte slice as a  quot bit stream quot  for example  for which we have a nice 3rd party lib  github com icza bitio  disclosure  I m the author   But Benchmark code still shows we re not winning  Why is it so  The answer to the last question is because rand Read   uses a loop and keeps calling Source Int63   until it fills the passed slice  Exactly what the RandStringBytesMaskImprSrc   solution does  without the intermediate buffer  and without the added complexity  That s why RandStringBytesMaskImprSrc   remains on the throne  Yes  RandStringBytesMaskImprSrc   uses an unsynchronized rand Source unlike rand Read    But the reasoning still applies  and which is proven if we use Rand Read   instead of rand Read    the former is also unsynchronzed   II  Benchmark All right  it s time for benchmarking the different solutions  Moment of truth  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  Just by switching from runes to bytes  we immediately have 24  performance gain  and memory requirement drops to one third  Getting rid of rand Intn   and using rand Int63   instead gives another 20  boost  Masking  and repeating in case of big indices  slows down a little  due to repetition calls   -22     But when we make use of all  or most  of the 63 random bits  10 indices from one rand Int63   call   that speeds up big time  3 times  If we settle with a  non-default  new  rand Source instead of rand Rand  we again gain 21   If we utilize strings Builder  we gain a tiny 3 5  in speed  but we also achieved 50  reduction in memory usage and allocations  That s nice  Finally if we dare to use package unsafe instead of strings Builder  we again gain a nice 14   Comparing the final to the initial solution  RandStringBytesMaskImprSrcUnsafe   is 6 3 times faster than RandStringRunes    uses one sixth memory and half as few allocations  Mission accomplished

User · Answer

Here is my way   Use math rand or crypto rand as you wish   func randStr len int  string       buff    make   byte  len      rand Read buff      str    base64 StdEncoding EncodeToString buff         Base 64 can be longer than len     return str  len

User · Answer

Use package uniuri  which generates cryptographically secure uniform  unbiased  strings   Disclaimer  I m the author of the package

User · Answer

Two possible options  there might be more of course     You can use the crypto rand package that supports reading random byte arrays  from  dev urandom  and is geared towards cryptographic random generation  see http   golang org pkg crypto rand  example Read   It might be slower than normal pseudo-random number generation though   Take a random number and hash it using md5 or something like this

User · Answer

If you are willing to add a few characters to your pool of allowed characters  you can make the code work with anything which provides random bytes through a io Reader  Here we are using crypto rand      len encodeURL     64  This allows  x  lt   265  x   64 to have an even    distribution  const encodeURL    ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-       A helper function create and fill a slice of length n with characters from    a-zA-Z0-9 -  It panics if there are any problems getting random bytes  func RandAsciiBytes n int    byte       output    make   byte  n          We will take n bytes  one byte for each character of output      randomness    make   byte  n          read all random        err    rand Read randomness      if err    nil           panic err                fill output     for pos    range output              get random item         random    uint8 randomness pos               random   64         randomPos    random   uint8 len encodeURL               put into output         output pos    encodeURL randomPos             return output

User · Answer

You can use this func  func randomString length int  string       b    make   byte  length      rand Read b      return fmt Sprintf  quot  x quot   b   length     Check it out in the playground

User · Answer

If you want cryptographically secure random numbers  and the exact charset is flexible  say  base64 is fine   you can calculate exactly what the length of random characters you need from the desired output size    Base 64 text is 1 3 longer than base 256   2 8 vs 2 6  8bits 6bits   1 333 ratio   import        crypto rand       encoding base64       math     func randomBase64String l int  string       buff    make   byte  int math Round float64 l  float64 1 33333333333         rand Read buff      str    base64 RawURLEncoding EncodeToString buff      return str  l     strip 1 extra character we get from odd length results     Note  you can also use RawStdEncoding if you prefer   and   characters to - and    If you want hex  base 16 is 2x longer than base 256   2 8 vs 2 4  8bits 4bits   2x ratio   import        crypto rand       encoding hex       math      func randomBase16String l int  string       buff    make   byte  int math Round float64 l  2        rand Read buff      str    hex EncodeToString buff      return str  l     strip 1 extra character we get from odd length results     However  you could extend this to any arbitrary character set if you have a base256 to baseN encoder for your character set  You can do the same size calculation with how many bits are needed to represent your character set  The ratio calculation for any arbitrary charset is  ratio   8   log2 len charset      Though both of these solutions are secure  simple  should be fast  and don t waste your crypto entropy pool   Here s the playground showing it works for any size  https   play golang org p i61WUVR8 3Z

User · Answer

You can just write code for it  This code can be a little simpler if you want to rely on the letters all being single bytes when encoded in UTF-8   package main  import        fmt       time       math rand     var letters     rune  abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ    func randSeq n int  string       b    make   rune  n      for i    range b           b i    letters rand Intn len letters              return string b     func main         rand Seed time Now   UnixNano         fmt Println randSeq 10

User · Answer

func Rand n int   str string        b    make   byte  n      rand Read b      str   fmt Sprintf   x   b      return

User · Answer

Following icza s wonderfully explained solution  here is a modification of it that uses crypto rand instead of math rand   const       letterBytes    abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ     52 possibilities     letterIdxBits   6                       6 bits to represent 64 possibilities   indexes     letterIdxMask   1 lt  lt letterIdxBits - 1    All 1-bits  as many as letterIdxBits    func SecureRandomAlphaString length int  string        result    make   byte  length      bufferSize    int float64 length  1 3      for i  j  randomBytes    0  0    byte    i  lt  length  j             if j bufferSize    0               randomBytes   SecureRandomBytes bufferSize                    if idx    int randomBytes j length   amp  letterIdxMask   idx  lt  len letterBytes                result i    letterBytes idx              i                        return string result        SecureRandomBytes returns the requested number of bytes using crypto rand func SecureRandomBytes length int    byte       var randomBytes   make   byte  length         err    rand Read randomBytes      if err    nil           log Fatal  Unable to generate random bytes             return randomBytes     If you want a more generic solution  that allows you to pass in the slice of character bytes to create the string out of  you can try using this      SecureRandomString returns a string of the requested length     made from the byte characters provided  only ASCII allowed      Uses crypto rand for security  Will panic if len availableCharBytes   gt  256  func SecureRandomString availableCharBytes string  length int  string           Compute bitMask     availableCharLength    len availableCharBytes      if availableCharLength    0    availableCharLength  gt  256           panic  availableCharBytes length must be greater than 0 and less than or equal to 256             var bitLength byte     var bitMask byte     for bits    availableCharLength - 1  bits    0            bits   bits  gt  gt  1         bitLength             bitMask   1 lt  lt bitLength - 1         Compute bufferSize     bufferSize    length   length   3         Create random string     result    make   byte  length      for i  j  randomBytes    0  0    byte    i  lt  length  j             if j bufferSize    0                  Random byte buffer is empty  get a new one             randomBytes   SecureRandomBytes bufferSize                       Mask bytes to get an index into the character slice         if idx    int randomBytes j length   amp  bitMask   idx  lt  availableCharLength               result i    availableCharBytes idx              i                        return string result      If you want to pass in your own source of randomness  it would be trivial to modify the above to accept an io Reader instead of using crypto rand

User · Answer

how random count in   count  one    big NewInt 0   big NewInt 1  count SetString  quot 100000000000000000000000 quot   10

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

The answer is

Examples related to string

Examples related to random

Examples related to go

Tags