Go 库代码中随机数生成与使用的最佳实践

package monte

import (
    "math"
    "math/rand"
)

const (
    DEFAULT_STEPS = 100000
)

// Naive 是一个简单的Monte Carlo积分器
type Naive struct {
    rand  *rand.Rand
    steps int
}

// NewNaive 创建一个Naive积分器实例。
// 它通过依赖注入接收一个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 对一维函数进行Monte Carlo积分
func (m *Naive) Integrate1D(fn func(float64) float64, a, b float64) float64 {
    var sum float64
    for i := 0; i < m.steps; i++ {
        // 生成[0, 1)范围内的随机数，然后映射到[a, b)
        x := a + (b-a)*m.rand.Float64()
        sum += fn(x)
    }
    return (b - a) * sum / float64(m.steps)
}

package main

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

    "your_module/monte" // 假设monte包在your_module下
)

func main() {
    // 使用固定种子，结果可重复
    mFixed := monte.NewNaive(rand.NewSource(200))
    piFixed := 4 * mFixed.Integrate1D(func(t float64) float64 {
        return math.Sqrt(1-t*t)
    }, 0, 1)
    fmt.Printf("固定种子计算的 Pi: %f\n", piFixed)

    // 使用时间种子，每次运行结果不同
    mTime := monte.NewNaive(rand.NewSource(time.Now().UnixNano()))
    piTime := 4 * mTime.Integrate1D(func(t float64) float64 {
        return math.Sqrt(1-t*t)
    }, 0, 1)
    fmt.Printf("时间种子计算的 Pi: %f\n", piTime)
}

package keygen

import (
    "crypto/rand"
    "encoding/base32"
    "fmt"
)

// GenKey 生成一个密码学安全的随机字符串作为密钥
func GenKey() (string, error) {
    b := make([]byte, 20) // 生成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"

    "your_module/keygen" // 假设keygen包在your_module下
)

func main() {
    key, err := keygen.GenKey()
    if err != nil {
        fmt.Println("生成密钥失败:", err)
        return
    }
    fmt.Println("生成的安全密钥:", key)
}

package shuffle

import (
    "math/rand"
    "time"
)

// r 是一个包私有的rand.Rand实例，用于本包内的随机数生成
var r *rand.Rand

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

// ShuffleStrings 对字符串切片进行Fisher-Yates洗牌
func ShuffleStrings(arr []string) {
    last := len(arr) - 1
    for i := range arr {
        // 从当前位置到切片末尾之间随机选择一个索引j
        // 注意：这里原问题代码中的 `r.Intn(last)` 应该改为 `r.Intn(last - i + 1) + i`
        // 或者更常见的写法是 `r.Intn(i + 1)` 从0到i选择
        // 考虑到Fisher-Yates洗牌算法的常见实现，这里修正为从0到i选择
        j := r.Intn(i + 1) // 随机选择一个索引，范围是 [0, i]
        arr[i], arr[j] = arr[j], arr[i]
    }
}

package main

import (
    "fmt"

    "your_module/shuffle" // 假设shuffle包在your_module下
)

func main() {
    arr := []string{"apple", "banana", "cherry", "date", "elderberry"}
    fmt.Printf("原始切片: %v\n", arr)

    for i := 0; i < 3; i++ {
        // 每次调用ShuffleStrings都会使用库内部独立的随机数生成器
        shuffle.ShuffleStrings(arr)
        fmt.Printf("第 %d 次洗牌: %v\n", i+1, arr)
    }

    // 应用程序仍然可以独立使用全局的rand包，不会受到shuffle库的影响
    // 例如：rand.Seed(123)
    // fmt.Println("全局随机数:", rand.Intn(100))
}