如何正确播种随机数生成器

我正在尝试在Go中生成一个随机字符串，这是我到目前为止编写的代码：

package main

import (
    "bytes"
    "fmt"
    "math/rand"
    "time"
)

func main() {
    fmt.Println(randomString(10))
}

func randomString(l int) string {
    var result bytes.Buffer
    var temp string
    for i := 0; i < l; {
        if string(randInt(65, 90)) != temp {
            temp = string(randInt(65, 90))
            result.WriteString(temp)
            i++
        }
    }
    return result.String()
}

func randInt(min int, max int) int {
    rand.Seed(time.Now().UTC().UnixNano())
    return min + rand.Intn(max-min)
}

我的执行速度很慢。使用进行播种time会在一定时间内带来相同的随机数，因此循环会一次又一次地迭代。如何改善我的代码？

每次设置相同的种子，您将获得相同的序列。因此，当然，如果您将种子设置为快速循环中的时间，则可能会多次调用相同的种子。

在您的情况下，当您调用randInt函数直到拥有不同的值时，您正在等待时间（由Nano返回）更改。

对于所有伪随机库，您仅需设置一次种子，例如在初始化程序时，除非您特别需要再现给定的序列（通常仅用于调试和单元测试）。

之后，您只需调用Intn即可获取下一个随机整数。

将rand.Seed(time.Now().UTC().UnixNano())行从randInt函数移至main的开头，一切将会更快。

另请注意，我认为您可以简化字符串的构建：

package main

import (
    "fmt"
    "math/rand"
    "time"
)

func main() {
    rand.Seed(time.Now().UTC().UnixNano())
    fmt.Println(randomString(10))
}

func randomString(l int) string {
    bytes := make([]byte, l)
    for i := 0; i < l; i++ {
        bytes[i] = byte(randInt(65, 90))
    }
    return string(bytes)
}

func randInt(min int, max int) int {
    return min + rand.Intn(max-min)
}

我不明白为什么人们在播种时间价值。以我的经验，这从来不是一个好主意。例如，虽然系统时钟可能以纳秒为单位表示，但系统的时钟精度不是纳秒。

该程序不应在Go操场上运行，但如果在计算机上运行它，则可以粗略估算出可以期望的精度类型。我看到大约1000000 ns的增量，所以增加了1 ms。那是20位未使用的熵。一直以来，高位大多是恒定的。

对您而言重要的程度会有所不同，但您只需使用种子的crypto/rand.Readas来源，就可以避免基于时钟的种子值的陷阱。它将为您提供您可能会在随机数中寻找的不确定性质量（即使实际实现本身仅限于一组不同且确定性的随机序列）。

import (
    crypto_rand "crypto/rand"
    "encoding/binary"
    math_rand "math/rand"
)

func init() {
    var b [8]byte
    _, err := crypto_rand.Read(b[:])
    if err != nil {
        panic("cannot seed math/rand package with cryptographically secure random number generator")
    }
    math_rand.Seed(int64(binary.LittleEndian.Uint64(b[:])))
}

作为附带说明，但与您的问题有关。您可以rand.Source使用此方法创建自己的方法，以避免使用锁来保护源代码的开销。所述rand包效用函数是便利的，但它们也使用锁罩下以防止源被同时使用。如果不需要，可以通过创建自己的方法Source并以非并行方式使用它来避免这种情况。无论如何，您不应该在两次迭代之间重新使用随机数生成器，它永远不会被设计为以这种方式使用。

只是为了后代而已：有时最好使用初始字符集字符串来生成随机字符串。如果该字符串应该由人工手动输入，则很有用；排除0，O，1和l可以帮助减少用户错误。

var alpha = "abcdefghijkmnpqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ23456789"

// generates a random string of fixed size
func srand(size int) string {
    buf := make([]byte, size)
    for i := 0; i < size; i++ {
        buf[i] = alpha[rand.Intn(len(alpha))]
    }
    return string(buf)
}

我通常将种子设置在一个init()块内。它们记录在这里：http : //golang.org/doc/effective_go.html#init

好吧，为什么这么复杂！

package main

import (
    "fmt"
    "math/rand"
    "time"
)

func main() {
    rand.Seed( time.Now().UnixNano())
    var bytes int

    for i:= 0 ; i < 10 ; i++{ 
        bytes = rand.Intn(6)+1
        fmt.Println(bytes)
        }
    //fmt.Println(time.Now().UnixNano())
}

这是基于dystroy的代码，但符合我的需要。

六岁了（兰特整数1 =< i =< 6）

func randomInt (min int , max int  ) int {
    var bytes int
    bytes = min + rand.Intn(max)
    return int(bytes)
}

上面的功能是完全一样的。

我希望这些信息有用。

这是十亿分之一秒，两次获得相同种子的机会是多少。
无论如何，感谢您的帮助，这是我基于所有输入的最终解决方案。

package main

import (
    "math/rand"
    "time"
)

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

// generates a random string
func srand(min, max int, readable bool) string {

    var length int
    var char string

    if min < max {
        length = min + rand.Intn(max-min)
    } else {
        length = min
    }

    if readable == false {
        char = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"
    } else {
        char = "ABCDEFHJLMNQRTUVWXYZabcefghijkmnopqrtuvwxyz23479"
    }

    buf := make([]byte, length)
    for i := 0; i < length; i++ {
        buf[i] = char[rand.Intn(len(char)-1)]
    }
    return string(buf)
}

// For testing only
func main() {
    println(srand(5, 5, true))
    println(srand(5, 5, true))
    println(srand(5, 5, true))
    println(srand(5, 5, false))
    println(srand(5, 7, true))
    println(srand(5, 10, false))
    println(srand(5, 50, true))
    println(srand(5, 10, false))
    println(srand(5, 50, true))
    println(srand(5, 10, false))
    println(srand(5, 50, true))
    println(srand(5, 10, false))
    println(srand(5, 50, true))
    println(srand(5, 4, true))
    println(srand(5, 400, true))
    println(srand(6, 5, true))
    println(srand(6, 5, true))
    println(srand(6, 5, true))
    println(srand(6, 5, true))
    println(srand(6, 5, true))
    println(srand(6, 5, true))
    println(srand(6, 5, true))
    println(srand(6, 5, true))
    println(srand(6, 5, true))
    println(srand(6, 5, true))
    println(srand(6, 5, true))
    println(srand(6, 5, true))
}

如果您的目的只是生成一个随机数的字符串，那么我认为没有必要将它与多个函数调用复杂化或每次都重置种子。

最重要的步骤是在实际运行之前调用一次种子函数rand.Init(x)。Seed使用提供的种子值将默认Source初始化为确定性状态。因此，建议在实际函数调用伪随机数生成器之前先调用它一次。

这是创建随机数字符串的示例代码

package main 
import (
    "fmt"
    "math/rand"
    "time"
)



func main(){
    rand.Seed(time.Now().UnixNano())

    var s string
    for i:=0;i<10;i++{
    s+=fmt.Sprintf("%d ",rand.Intn(7))
    }
    fmt.Printf(s)
}

我之所以使用Sprintf是因为它允许简单的字符串格式化。

另外，In rand.Intn(7) Intn将[0,7）中的非负伪随机数作为int返回。

@ [DenysSéguret]已正确发布。但是就我而言，我每次都需要新的种子，因此下面的代码；

如果您需要快速功能。我这样使用。

func RandInt(min, max int) int {
    r := rand.New(rand.NewSource(time.Now().UnixNano()))
    return r.Intn(max-min) + min
}

func RandFloat(min, max float64) float64 {
    r := rand.New(rand.NewSource(time.Now().UnixNano()))
    return min + r.Float64()*(max-min)
}

资源

由于golang api的更改而导致的小更新，请省略.UTC（）：

现在的时间（）。UTC（）. UnixNano（）-> time.Now（）。UnixNano（）

import (
    "fmt"
    "math/rand"
    "time"
)

func main() {
    rand.Seed(time.Now().UnixNano())
    fmt.Println(randomInt(100, 1000))
}

func randInt(min int, max int) int {
    return min + rand.Intn(max-min)
}