blocks|key|4637877|text|你可以只为它写代码。如果您希望在使用UTF-8编码时，所有字母都是单字节，则此代码可以稍微简单一些。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4637878|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))
}|code-block|syntax|javascript|4637879|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

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.

<pre><code>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))
}
</code></pre>

blocks|key|4637927|text|使用uniuri包，它会生成加密安全的统一(无偏)字符串。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|4637928|免责声明:我是包的作者|4637929|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/dchest/uniuri^0|2|6|0|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@$A|O|B|P|1|Q]]|C|$]]|$1|D|3|E|5|6|7|R|8|@]|9|@]|C|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|C|$]]]|G|$H|$5|I|J|K|C|$L|M]]]]

Use package <a href="https://github.com/dchest/uniuri" rel="noreferrer">uniuri</a>, which generates cryptographically secure uniform (unbiased) strings.

Disclaimer: I'm the author of the package

blocks|key|131887|text|为您提供简单解决方案，重复结果最少：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|131888|import+(
++++"math/rand"
++++"time"
)

func+randomString(length+int)+string+{
++++rand.Seed(time.Now().UnixNano())
++++b+:=+make([]byte,+length)
++++rand.Read(b)
++++return+fmt.Sprintf("%25x",+b)[:length]
}|code-block|syntax|javascript|131889|在PlayGround中查看它|offset|length|131890|entityMap|0|LINK|mutability|MUTABLE|url|https://play.golang.org/p/pJwDbV-OYH7^0|0|0|1|A|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@$I|V|J|W|1|X]]|A|$]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|L|$M|$5|N|O|P|A|$Q|R]]]]

Simple solution for you, with least duplicate result:
<pre class="lang-golang prettyprint-override"><code>import (
 &quot;math/rand&quot;
 &quot;time&quot;
)

func randomString(length int) string {
 rand.Seed(time.Now().UnixNano())
 b := make([]byte, length)
 rand.Read(b)
 return fmt.Sprintf(&quot;%x&quot;, b)[:length]
}
</code></pre>
Check it out in the <a href="https://play.golang.org/p/pJwDbV-OYH7" rel="noreferrer">PlayGround</a>

blocks|key|4637986|text|遵循icza's精彩解释的解决方案，这里是它的一个修改，使用crypto/rand而不是math/rand。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4637987|const+(
++++letterBytes+=+"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"+//+52+possibilities
++++letterIdxBits+=+6++++++++++++++++++++//+6+bits+to+represent+64+possibilities+/+indexes
++++letterIdxMask+=+1<<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+<+length;+j%2B%2B+{
++++++++if+j%25bufferSize+==+0+{
++++++++++++randomBytes+=+SecureRandomBytes(bufferSize)
++++++++}
++++++++if+idx+:=+int(randomBytes[j%25length]+&+letterIdxMask);+idx+<+len(letterBytes)+{
++++++++++++result[i]+=+letterBytes[idx]
++++++++++++i%2B%2B
++++++++}
++++}

++++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
}|code-block|syntax|javascript|4637988|如果您想要一个更通用的解决方案，它允许您传入字符字节的片段来创建字符串，您可以尝试使用以下命令：|4637989|//+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)+>+256.
func+SecureRandomString(availableCharBytes+string,+length+int)+string+{

++++//+Compute+bitMask
++++availableCharLength+:=+len(availableCharBytes)
++++if+availableCharLength+==+0+%7C%7C+availableCharLength+>+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+>>+1
++++++++bitLength%2B%2B
++++}
++++bitMask+=+1<<bitLength+-+1

++++//+Compute+bufferSize
++++bufferSize+:=+length+%2B+length+/+3

++++//+Create+random+string
++++result+:=+make([]byte,+length)
++++for+i,+j,+randomBytes+:=+0,+0,+[]byte{};+i+<+length;+j%2B%2B+{
++++++++if+j%25bufferSize+==+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%25length]+&+bitMask);+idx+<+availableCharLength+{
++++++++++++result[i]+=+availableCharBytes[idx]
++++++++++++i%2B%2B
++++++++}
++++}

++++return+string(result)
}|4637990|如果您想传入您自己的随机性来源，修改上面的代码以接受io.Reader而不是使用crypto/rand将是微不足道的。|4637991|entityMap^0|2|6|U|B|18|9|0|0|0|0|Q|9|14|B|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]|$9|V|A|W|B|C]|$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|Z|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|10|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|11|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|12|8|@$9|13|A|14|B|C]|$9|15|A|16|B|C]]|D|@]|E|$]]|$1|Q|3|-4|5|6|7|17|8|@]|D|@]|E|$]]]|R|$]]

Following <code>icza's</code> wonderfully explained solution, here is a modification of it that uses <code>crypto/rand</code> instead of <code>math/rand</code>.

<pre><code>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
}
</code></pre>

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:

<pre><code>// 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)
}
</code></pre>

If you want to pass in your own source of randomness, it would be trivial to modify the above to accept an <code>io.Reader</code> instead of using <code>crypto/rand</code>.

blocks|key|131793|text|func+Rand(n+int)+(str+string)+{
++++b+:=+make([]byte,+n)
++++rand.Read(b)
++++str+=+fmt.Sprintf("%25x",+b)
++++return
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|131794|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>func Rand(n int) (str string) {
 b := make([]byte, n)
 rand.Read(b)
 str = fmt.Sprintf("%x", b)
 return
}
</code></pre>

blocks|key|4638410|text|另一个版本，灵感来自generate+password+in+JavaScript+crypto|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|4638411|package+main

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

var+chars+=+"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890-"

func+shortID(length+int)+string+{
++++ll+:=+len(chars)
++++b+:=+make([]byte,+length)
++++rand.Read(b)+//+generates+len(b)+random+bytes
++++for+i+:=+0;+i+<+length;+i%2B%2B+{
++++++++b[i]+=+chars[int(b[i])%25ll]
++++}
++++return+string(b)
}

func+main()+{
++++fmt.Println(shortID(18))
++++fmt.Println(shortID(18))
++++fmt.Println(shortID(18))
}|code-block|syntax|javascript|4638412|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/51540480/1099314^0|A|12|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

Another version, inspired from <a href="https://stackoverflow.com/a/51540480/1099314">generate password in JavaScript crypto</a>:
<pre><code>package main

import (
 &quot;crypto/rand&quot;
 &quot;fmt&quot;
)

var chars = &quot;abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890-&quot;

func shortID(length int) string {
 ll := len(chars)
 b := make([]byte, length)
 rand.Read(b) // generates len(b) random bytes
 for i := 0; i &lt; length; i++ {
 b[i] = chars[int(b[i])%ll]
 }
 return string(b)
}

func main() {
 fmt.Println(shortID(18))
 fmt.Println(shortID(18))
 fmt.Println(shortID(18))
}
</code></pre>

blocks|key|4638225|text|这是我的方法)使用数学rand或crypto+rand随你所愿。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4638226|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]
}|code-block|syntax|javascript|4638227|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Here is my way ) Use math rand or crypto rand as you wish.

<pre><code>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]
}
</code></pre>

blocks|key|4638329|text|对于加密安全的随机字符串，这里有一个简单而高效的解决方案。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4638330|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%2B%2B+{
++++++++b[i]+=+alphabet[b[i]+/+5]
++++}
++++return+*(*string)(unsafe.Pointer(&b))
}|code-block|syntax|javascript|4638331|基准测试|4638332|Benchmark++95.2+ns/op++++++16+B/op++++++1+allocs/op|4638333|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Here is a simple and performant solution for a cryptographically secure random string.
<pre><code>package main

import (
 &quot;crypto/rand&quot;
 &quot;unsafe&quot;
 &quot;fmt&quot;
)

var alphabet = []byte(&quot;abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ&quot;)

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

func generate(size int) string {
 b := make([]byte, size)
 rand.Read(b)
 for i := 0; i &lt; size; i++ {
 b[i] = alphabet[b[i] / 5]
 }
 return *(*string)(unsafe.Pointer(&amp;b))
}
</code></pre>
Benchmark
<pre><code>Benchmark 95.2 ns/op 16 B/op 1 allocs/op
</code></pre>

blocks|key|131716|text|如果您愿意向允许的字符池中添加几个字符，则可以通过io.Reader使代码与提供随机字节的任何内容一起工作。这里我们使用的是crypto/rand。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|131717|//+len(encodeURL)+==+64.+This+allows+(x+<=+265)+x+%25+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+%25+64
++++++++randomPos+:=+random+%25+uint8(len(encodeURL))

++++++++//+put+into+output
++++++++output[pos]+=+encodeURL[randomPos]
++++}

++++return+output
}|code-block|syntax|javascript|131718|entityMap^0|1Q|B|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

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 <code>crypto/rand</code>.

<pre><code>// 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
}
</code></pre>

blocks|key|4638445|text|这是一个示例代码，我用它在我的应用程序中生成证书编号。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4638446|func+GenerateCertificateNumber()+string+{
++++CertificateLength+:=+7
++++t+:=+time.Now().String()
++++CertificateHash,+err+:=+bcrypt.GenerateFromPassword([]byte(t),+bcrypt.DefaultCost)
++++if+err+!=+nil+{
++++++++fmt.Println(err)
++++}
++++//+Make+a+Regex+we+only+want+letters+and+numbers
++++reg,+err+:=+regexp.Compile("[%5Ea-zA-Z0-9]%2B")
++++if+err+!=+nil+{
++++++++log.Fatal(err)
++++}
++++processedString+:=+reg.ReplaceAllString(string(CertificateHash),+"")
++++fmt.Println(string(processedString))

++++CertificateNumber+:=+strings.ToUpper(string(processedString[len(processedString)-CertificateLength:]))
++++fmt.Println(CertificateNumber)
++++return+CertificateNumber
}|code-block|syntax|javascript|4638447|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

This is a sample code which I used to generate certificate number in my app.
<pre><code>func GenerateCertificateNumber() string {
 CertificateLength := 7
 t := time.Now().String()
 CertificateHash, err := bcrypt.GenerateFromPassword([]byte(t), bcrypt.DefaultCost)
 if err != nil {
 fmt.Println(err)
 }
 // Make a Regex we only want letters and numbers
 reg, err := regexp.Compile(&quot;[^a-zA-Z0-9]+&quot;)
 if err != nil {
 log.Fatal(err)
 }
 processedString := reg.ReplaceAllString(string(CertificateHash), &quot;&quot;)
 fmt.Println(string(processedString))

 CertificateNumber := strings.ToUpper(string(processedString[len(processedString)-CertificateLength:]))
 fmt.Println(CertificateNumber)
 return CertificateNumber
}
</code></pre>

blocks|key|4638301|text|/*
++++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+:=+&sync.Pool{New:+func()+interface{}+{
++++++++return+rand.New(rand.NewSource(getSeed()))
++++},
++++}
++++mrand+:=+&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+<+len;+i%2B%2B+{
++++++++b[i]+=+randlist[b[i]%25(62)]
++++}
++++return+*(*string)(unsafe.Pointer(&b))
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|4638302|24.0+ns/op+16+B/op+1分配/|unstyled|4638303|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|J|8|@]|9|@]|A|$]]|$1|G|3|-4|5|F|7|K|8|@]|9|@]|A|$]]]|H|$]]

<pre><code>/*
 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))
}
</code></pre>

24.0 ns/op 16 B/op 1 allocs/

blocks|key|4638390|text|随机计数：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4638391|count,+one+:=+big.NewInt(0),+big.NewInt(1)
count.SetString("100000000000000000000000",+10)|code-block|syntax|javascript|4638392|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

how random count in :
<pre><code>count, one := big.NewInt(0), big.NewInt(1)
count.SetString(&quot;100000000000000000000000&quot;, 10)
</code></pre>

blocks|key|131787|text|const+(
++++chars+++++++=+"0123456789_abcdefghijkl-mnopqrstuvwxyz"+//ABCDEFGHIJKLMNOPQRSTUVWXYZ
++++charsLen++++=+len(chars)
++++mask++++++++=+1<<6+-+1
)

var+rng+=+rand.NewSource(time.Now().UnixNano())

//+RandStr+返回指定长度的随机字符串
func+RandStr(ln+int)+string+{
++++/*+chars+38个字符
+++++*+rng.Int63()+每次产出64bit的随机数,每次我们使用6bit(2%5E6=64)+可以使用10次
+++++*/
++++buf+:=+make([]byte,+ln)
++++for+idx,+cache,+remain+:=+ln-1,+rng.Int63(),+10;+idx+>=+0;+{
++++++++if+remain+==+0+{
++++++++++++cache,+remain+=+rng.Int63(),+10
++++++++}
++++++++buf[idx]+=+chars[int(cache&mask)%25charsLen]
++++++++cache+>>=+6
++++++++remain--
++++++++idx--
++++}
++++return+*(*string)(unsafe.Pointer(&buf))
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|131788|BenchmarkRandStr16-8+20000000+68.1+ns/op+16+B/op+1分配/op|unstyled|131789|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|J|8|@]|9|@]|A|$]]|$1|G|3|-4|5|F|7|K|8|@]|9|@]|A|$]]]|H|$]]

<pre><code>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))
}
</code></pre>

BenchmarkRandStr16-8 20000000 68.1 ns/op 16 B/op 1 allocs/op

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?

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

我只想要一个随机字符串的字符(大写或小写)，没有数字，在Go。完成此操作的最快、最简单的方法是什么？

问如何在Go中生成固定长度的随机字符串？
EN

回答 13

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何在Go中生成固定长度的随机字符串？EN

回答 13

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何在Go中生成固定长度的随机字符串？
EN