Go 生成随机数

在编写抽奖活动、生成短信验证码、模拟游戏掉落概率,或者随机打乱题目顺序时,我们都会用到 “随机数”。

在 Go 语言中,使用标准库 math/rand 包就可以生成随机整数和随机小数。从 Go 1.20 开始,程序在启动时会自动初始化随机种子,我们每次运行代码都会直接产生不同的随机结果。

生成随机整数:rand.Intn()

在 Go 语言中,如果我们想要生成一个非负的随机整数,最常用的是 math/rand 包中的 rand.Intn() 函数。

语法:

rand.Intn(n)

说明:

参数 n 是一个大于 0 的 int 整数。调用后,rand.Intn(n) 会返回一个落在 [0, n) 左闭右开区间内的随机整数,也就是包含 0 但不包含 n,最大只能取到 n - 1。

注意: 传给 rand.Intn(n) 的参数 n 必须大于 0。如果我们不小心传入了 0 或负数,比如执行 rand.Intn(0),程序在运行时会直接触发 panic 崩溃。

示例 1:生成 [0, n) 内的随机整数

package main

import (
    "fmt"
    "math/rand"
)

func main() {
    // 连续生成 5 个 0 ~ 9 之间的随机整数
    for i := 0; i < 5; i++ {
        fmt.Println(rand.Intn(10))
    }
}

运行结果如下。

7
2
9
0
4

分析:

rand.Intn(10) 遵循 “含头不含尾” 的规则:它最小可能生成 0,最大可能生成 9,但不会生成 10。因为每次运行都是随机生成的,所以小伙伴们实际运行这段代码时,打印出来的 5 个数字会跟上面展示的结果不一样。

生成 [min, max] 区间内的随机整数

rand.Intn(n) 总是从 0 开始生成随机数。但在日常开发中,我们经常需要生成某个指定闭区间内的随机整数,比如掷骰子生成 1 ~ 6 之间的点数,或者生成 100000 ~ 999999 之间的 6 位数字验证码。

怎么把起点从 0 移到指定的最小值呢?我们可以先拿掷骰子(1 ~ 6 点)来推算一下:rand.Intn(6) 生成的范围是 0 ~ 5,只要在后面加上 1 写成 rand.Intn(6) + 1,范围就变成了 1 ~ 6。

推广到任意的最小值 min 和最大值 max(两头都包含),区间内一共包含 max - min + 1 个整数,映射关系如下图所示。

将 [0, n) 映射为 [min, max] 闭区间随机数的原理

语法:

rand.Intn(max-min+1) + min

说明:

公式里的 min 和 max 分别代表区间的最小值和最大值,要求 max >= min,生成的随机整数两头都能取到。注意这里的 min 和 max 仅作数学占位表示,实际写代码时建议起名为 minVal 和 maxVal,避免覆盖上一节学过的内置函数 max() 和 min()。

示例 2:生成指定区间的随机整数

package main

import (
    "fmt"
    "math/rand"
)

func main() {
    // 1. 生成 1 ~ 100 之间的随机整数
    minVal := 1
    maxVal := 100
    num := rand.Intn(maxVal-minVal+1) + minVal
    fmt.Println(num)

    // 2. 生成 100000 ~ 999999 之间的 6 位随机验证码
    code := rand.Intn(900000) + 100000
    fmt.Println(code)
}

运行结果如下。

68
539204

分析:

先看生成 1 ~ 100 随机整数的代码:minVal 为 1、maxVal 为 100,套用公式 rand.Intn(100-1+1) + 1 就能得到 1 ~ 100 之间的随机结果。

再看生成 6 位验证码的写法:最小的 6 位数是 100000,最大是 999999,区间内共有 900000 个整数(999999 - 100000 + 1)。调用 rand.Intn(900000) 会生成 0 ~ 899999 之间的随机数,加上 100000 后就会落在 100000 ~ 999999 之间。

在使用这个区间公式时,很多初学者容易漏掉括号里的 + 1。

// 正确方式
num := rand.Intn(maxVal-minVal+1) + minVal

// 错误方式
num := rand.Intn(maxVal-minVal) + minVal

如果漏掉了 + 1,当 minVal 为 1、maxVal 为 100 时,rand.Intn(100 - 1) 实际上变成了 rand.Intn(99),只能生成 0 ~ 98。后面再加上 1 之后,最终范围只有 1 ~ 99,永远也随机不到最大值 100。

提示: math/rand 包生成的是伪随机数,计算速度非常快,适合抽奖、游戏和普通短信验证码等日常场景。如果是生成高安全要求的密码重置令牌或加密密钥,则应该使用标准库中的 crypto/rand 包。

生成随机小数:rand.Float64()

除了生成随机整数,在模拟百分比概率或生成随机测试价格时,我们还会用到随机小数。在 Go 语言中,我们可以使用 rand.Float64() 函数来生成 0.0 到 1.0 之间的随机浮点数。

语法:

rand.Float64()

说明:

rand.Float64() 不需要传入任何参数,调用后会直接返回一个落在 [0.0, 1.0) 左闭右开区间内的随机浮点数,也就是包含 0.0 但不包含 1.0。

示例 3:生成随机浮点数

package main

import (
    "fmt"
    "math/rand"
)

func main() {
    // 生成 [0.0, 1.0) 之间的随机小数
    f1 := rand.Float64()
    fmt.Println(f1)

    // 生成 [0.0, 100.0) 之间的随机小数,保留 2 位小数打印
    f2 := rand.Float64() * 100
    fmt.Printf("%.2f\n", f2)
}

运行结果如下。

0.6046602879796196
43.77

分析:

rand.Float64() 默认返回 0.0 到 1.0 之间的随机小数。想要生成 0.0 到 100.0 之间的随机小数,我们只需要将结果乘以 100。如果想要生成任意 [minVal, maxVal) 区间内的随机小数,套用 minVal + rand.Float64()*(maxVal-minVal) 就可以了。

随机打乱切片:rand.Shuffle()

实际写代码时,我们还经常遇到另一种随机需求:把一个切片里的元素顺序随机打乱,比如扑克牌洗牌或随机打乱考题顺序。在 Go 语言中,我们可以使用 rand.Shuffle() 函数来实现。其中,shuffle 是英文 “洗牌” 的意思。

语法:

rand.Shuffle(n, func(i, j int) {
    // 交换下标 i 和 j 的元素
})

说明:

rand.Shuffle() 没有返回值,会直接原地打乱切片中的元素顺序。假设待打乱的切片名为 s,它接收以下 2 个必选参数:

  • n(必选):需要打乱的元素总个数,平时直接传入切片的长度 len(s) 即可。
  • func(i, j int)(必选):用于交换元素的匿名函数,函数体内写成 s[i], s[j] = s[j], s[i] 即可交换下标 i 和 j 处的两个元素。

很多小伙伴刚见到这个写法会纳闷:为什么不能直接写 rand.Shuffle(s),非要多传一个交换函数呢?其实是因为 math/rand 诞生在 Go 语言引入泛型之前。把 “怎么交换两个位置” 交给匿名函数后,rand.Shuffle() 就不挑切片的元素类型了,整数、字符串或结构体切片都可以直接使用它来洗牌。

示例 4:随机打乱切片顺序

package main

import (
    "fmt"
    "math/rand"
)

func main() {
    cards := []string{"A", "2", "3", "4", "5"}

    // 随机打乱切片中元素的顺序
    rand.Shuffle(len(cards), func(i, j int) {
        cards[i], cards[j] = cards[j], cards[i]
    })

    fmt.Println(cards)
}

运行结果如下。

[3 A 5 2 4]

分析:

在这个例子中,第 1 个参数传入了切片长度 len(cards),告诉 rand.Shuffle() 一共有 5 张牌需要打乱。

执行洗牌时,rand.Shuffle() 会在内部随机挑出两个下标 i 和 j,并反复调用后面的匿名函数。函数体内的 cards[i], cards[j] = cards[j], cards[i] 利用平行赋值互换这两张牌的位置,最终把整个 cards 切片原地打乱。

随机种子与 math/rand/v2

小伙伴们在查阅早期资料或阅读其他项目代码时,经常会见到下面这三种与随机数相关的写法,这里我们简单了解一下:

  • 已废弃的 rand.Seed():在 Go 1.20 之前,我们需要先调用 UnixNano() 获取当前纳秒时间戳并传给 rand.Seed() 初始化随机种子,否则每次运行生成的随机数都一模一样。从 Go 1.20 起程序会自动完成初始化,不再需要手写这行代码。
  • 可复现的局部随机器:在写单元测试或排查问题时,如果我们恰恰希望每次运行都生成一模一样的随机序列,可以通过 r := rand.New(rand.NewSource(42)) 创建固定种子的局部随机器。之后调用 r.Intn(10) 生成随机数,既方便复现,又不会影响全局随机状态。
  • 升级版 math/rand/v2 包:Go 1.22 引入了升级版的 math/rand/v2 标准库,优化了底层随机算法,并将原来的 rand.Intn(10) 改名为了末尾大写的 rand.IntN(10)。日常开发中这两个包都很常见,基础用法基本一致。
给站长反馈

绿叶网正在不断完善中,小伙伴们如果发现任何问题,还望多多给站长反馈,谢谢!

邮箱:lvyenet@vip.qq.com

「绿叶网」服务号
绿叶网服务号放大
关注服务号,微信也能看教程。
绿叶网服务号