本文深入探讨了在javascript中生成指定范围唯一随机数时可能遇到的rangeerror: maximum call stack size exceeded问题。通过分析导致栈溢出的低效递归方法，文章介绍了一种基于数组操作和洗牌算法的高效解决方案，该方法简洁、性能优越，能够有效避免递归陷阱，确保生成结果的正确性和程序的稳定性。
在JavaScript开发中，我们经常需要生成一系列随机数。当需求进一步细化为“生成指定范围内的唯一随机数”时，如果不采用恰当的算法，很容易遇到程序性能瓶颈甚至运行时错误。其中一个常见的错误便是RangeError: Maximum Call Stack Size Exceeded，尤其是在使用不当的递归逻辑时。
理解 RangeError: Maximum Call Stack Size Exceeded
RangeError: Maximum Call Stack Size Exceeded 错误表示JavaScript执行引擎的调用栈（Call Stack）溢出。调用栈是一个LIFO（后进先出）的数据结构，用于存储程序执行过程中函数的调用信息。每当一个函数被调用，其信息（如参数、局部变量、返回地址）就会被推入栈中；函数执行完毕后，其信息则从栈中弹出。如果函数以无限或深度过大的递归方式调用自身，或者函数链式调用过长，调用栈就会不断增长，最终超出其预设的最大深度限制，从而引发栈溢出错误。
考虑以下生成24个1到24之间唯一随机数的原始尝试代码片段（为简洁，仅展示部分）：
let d1 = 0;
// ... d2 to d24
function getRandomInt(max) {
return Math.floor(Math.random() * max);
}
function generated1() {
d1 = getRandomInt(24);
if (d1 == 0) { // 假设0不是有效值，需要重新生成
generated1(); // 递归调用
} else {
generated2();
}
}
function generated2() {
d2 = getRandomInt(24);
if (d2 == d1 || d2 == 0) { // 检查是否重复或无效
generated2(); // 递归调用
} else {
generated3();
}
}
// ... 类似的 generated3() 到 generated24() 函数上述代码的逻辑是为每个变量 dX 生成一个随机数，并检查它是否与之前生成的 d1 到 dX-1 中的任何一个重复，或者是否为无效值（例如0）。如果存在重复或无效，函数会递归调用自身以尝试生成一个新的数字。这种“生成-检查-重试”的递归模式在数字范围较小且需要生成大量唯一数时尤其脆弱。
立即学习“Java免费学习笔记（深入）”；
这种方法的缺陷在于：
- 高冲突概率：随着已生成唯一数字的数量增加，每次生成新数字时遇到冲突的概率会急剧上升。例如，当尝试生成 d20 时，它需要与 d1 到 d19 这19个数字以及0都不相同。
- 深度递归：一旦发生冲突，函数就会立即递归调用自身。如果连续发生多次冲突，或者在数字池接近耗尽时（例如，只剩几个可用数字但随机数生成器频繁命中已用数字），递归调用的深度将迅速增加。
- 栈溢出：当递归深度超过JavaScript引擎的限制时（通常几千到几万层），就会导致RangeError: Maximum Call Stack Size Exceeded错误。
高效生成唯一随机数的策略
为了避免上述问题，更健壮和高效的方法是采用“洗牌”（shuffle）算法。其核心思想是：首先创建一个包含所有可能数字的有序列表，然后将其随机打乱。这样，我们既能保证数字的唯一性，又能避免深度递归带来的栈溢出风险。
以下介绍两种常用的洗牌策略。
方法一：Fisher-Yates (Knuth) 洗牌算法
Fisher-Yates（也称为Knuth）洗牌算法是一种经典的、能够生成无偏随机排列的算法。它的时间复杂度为 O(N)，非常高效。
算法步骤：
- 创建一个包含所有待选数字的数组（例如 [1, 2, ..., 24]）。
- 从数组的最后一个元素开始，向前遍历到第二个元素（索引 i 从 N-1 到 1）。
- 在每次迭代中，生成一个随机索引 j，其范围是从 0 到 i（包含 i）。
- 交换当前元素 arr[i] 和随机选中的元素 arr[j]。
示例代码：
function shuffleArray(array) {
for (let i = array.length - 1; i > 0; i--) {
const j = Math.floor(Math.random() * (i + 1)); // 生成 0 到 i 之间的随机索引
[array[i], array[j]] = [array[j], array[i]]; // 交换元素
}
return array;
}
const numbers = Array.from({ length: 24 }, (_, i) => i + 1); // 生成 [1, 2, ..., 24]
const uniqueRandomNumbers = shuffleArray(numbers);
console.log(uniqueRandomNumbers); // 输出一个包含24个1到24的唯一随机数的数组方法二：利用 Array.prototype.sort() 和 Math.random()
这种方法利用JavaScript数组的 sort() 方法，结合 Math.random() 来实现洗牌。虽然在理论上 sort 方法的随机性可能不如 Fisher-Yates 算法那么“无偏”，但对于大多数非密码学级别的随机需求，它提供了一种非常简洁的实现方式，尤其适用于生成固定范围的唯一随机数。
示例代码：
const length = 24;
const uniqueShuffledNumbers = Array
.from({length}, (_, idx) => ({idx, sort: Math.random()})) // 1. 生成包含索引和随机排序键的对象数组
.sort((a, b) => a.sort - b.sort) // 2. 根据随机排序键对数组进行排序（洗牌）
.map(({idx}) => idx + 1); // 3. 提取原始索引并加1，得到1到length的随机数
console.log(uniqueShuffledNumbers);代码解析：
-
Array.from({length}, (_, idx) => ({idx, sort: Math.random()}))：
- Array.from({length}) 创建一个长度为 length 的空数组。
- 回调函数 (_, idx) => ({idx, sort: Math.random()}) 为数组的每个位置生成一个对象。
- idx 是当前元素的索引（从0到 length-1）。
- sort: Math.random() 为每个对象添加一个随机的 sort 属性，其值在0（包含）到1（不包含）之间。
- 结果是一个类似 [{idx: 0, sort: 0.123}, {idx: 1, sort: 0.876}, ...] 的数组。
-
.sort((a, b) => a.sort - b.sort)：
- 这是数组的 sort() 方法，它根据比较函数的结果对数组元素进行排序。
- a.sort - b.sort 会根据 sort 属性的随机值进行升序排列。由于 sort 值是随机的，这实际上起到了打乱数组元素顺序的作用，从而实现了洗牌。
`.map(({idx}) => idx
