Go 库中随机数生成的最佳实践

type Source interface {
    Int63() int64
    Seed(seed int64)
}

package monte

import (
    "math/rand"
)

const (
    DEFAULT_STEPS = 100000
)

// Naive 结构体封装了随机数生成器和积分步数
type Naive struct {
    rand  *rand.Rand
    steps int
}

// NewNaive 构造函数接收一个 rand.Source 接口，允许用户提供自定义的随机数源
func NewNaive(source rand.Source) *Naive {
    return &Naive{rand.New(source), DEFAULT_STEPS}
}

// SetSteps 设置积分步数
func (m *Naive) SetSteps(steps int) {
    m.steps = steps
}

// Integrate1D 执行一维蒙特卡洛积分
func (m *Naive) Integrate1D(fn func(float64) float64, a, b float64) float64 {
    var sum float64
    for i := 0; i < m.steps; i++ {
        x := (b-a)*m.rand.Float64() + a // 在 [a, b) 范围内生成随机数
        sum += fn(x)
    }
    return (b - a) * sum / float64(m.steps)
}

package main

import (
    "fmt"
    "math"
    "math/rand"
    "time" // 引入 time 包用于生成种子
    "monte" // 引入你的 monte 包
)

func main() {
    // 应用程序可以提供自己的随机数源，例如使用当前时间作为种子
    // 也可以为了测试或特定目的，提供一个固定种子的源
    source := rand.NewSource(time.Now().UTC().UnixNano())
    m := monte.NewNaive(source)

    // 计算圆周率
    pi := 4 * m.Integrate1D(func(t float64) float64 {
        return math.Sqrt(1 - t*t)
    }, 0, 1)
    fmt.Printf("估算的圆周率: %f\n", pi)

    // 也可以使用固定种子进行可重现的测试
    mFixed := monte.NewNaive(rand.NewSource(200))
    piFixed := 4 * mFixed.Integrate1D(func(t float64) float64 {
        return math.Sqrt(1 - t*t)
    }, 0, 1)
    fmt.Printf("固定种子估算的圆周率: %f\n", piFixed)
}

package shuffle

import (
    "math/rand"
    "time"
)

// r 是包私有的 rand.Rand 实例
var r *rand.Rand

// init 函数在包加载时初始化私有的随机数生成器
func init() {
    // 使用当前时间作为种子，创建并初始化一个独立的 rand.Rand 实例
    r = rand.New(rand.NewSource(time.Now().UTC().UnixNano()))
}

// ShuffleStrings 对字符串切片进行洗牌
func ShuffleStrings(arr []string) {
    last := len(arr) - 1
    for i := range arr {
        // 在 [0, last] 范围内生成随机索引 j
        j := r.Intn(last + 1) // Intn(n) 返回 [0, n)
        arr[i], arr[j] = arr[j], arr[i]
    }
}

package main

import (
    "fmt"
    "shuffle" // 引入你的 shuffle 包
)

func main() {
    arr := []string{"a", "set", "of", "words", "to", "shuffle"}
    fmt.Printf("原始切片: %v\n", arr)
    for i := 0; i < 3; i++ {
        shuffle.ShuffleStrings(arr)
        fmt.Printf("洗牌后 %d: %v\n", i+1, arr)
    }

    // 应用程序不需要关心或初始化随机数生成器，库内部已处理
}

package keygen

import (
    "crypto/rand"
    "encoding/base32"
    "fmt" // 引入 fmt 用于错误处理
)

// GenKey 生成一个加密安全的随机密钥字符串
func GenKey() (string, error) {
    // 生成20字节的随机数据
    b := make([]byte, 20)
    if _, err := rand.Read(b); err != nil {
        return "", fmt.Errorf("无法读取加密随机数: %w", err)
    }

    // 使用Base32编码将字节转换为可读字符串
    // 这里的编码字符集可以根据需求调整
    enc := base32.NewEncoding("ABCDEFGHIJKLMNOPQRSTUVWXYZ346789")
    return enc.EncodeToString(b), nil
}

package main

import (
    "fmt"
    "keygen" // 引入你的 keygen 包
)

func main() {
    key, err := keygen.GenKey()
    if err != nil {
        fmt.Printf("生成密钥失败: %v\n", err)
        return
    }
    fmt.Printf("生成的加密密钥: %s\n", key)

    key2, err := keygen.GenKey()
    if err != nil {
        fmt.Printf("生成密钥失败: %v\n", err)
        return
    }
    fmt.Printf("生成的加密密钥: %s\n", key2)
}