最低和最高之间的随机整数：

function randomRange(low, high) {
  var range = (high-low);
  var random = Math.floor(Math.random()*range);
  if (random === 0) {
    random += 1;
  }
  return low + random;
}

这不是最优雅的解决方案，而是快速的解决方案。

伊奥努·G·斯坦写了一个很棒的答案，但对我来说有点太复杂了。因此，我在Math.floor（Math.random（）*（max-min+1））+min）中找到了对相同概念的更简单的解释。

注意：在阅读Jason的解释之前，你应该知道的唯一重要的事情是“truncate”的定义。他在描述Math.floor（）时使用了这个术语。牛津词典将“truncate”定义为：

通过切掉顶端或末端来缩短（某物）。

一个名为randUpTo的函数，它接受一个数字并返回一个介于0和该数字之间的随机整数：

var randUpTo = function(num) {
    return Math.floor(Math.random() * (num - 1) + 0);
};

一个名为randBetween的函数，它接受表示一个范围的两个数字，并返回这两个数字之间的随机整数：

var randBetween = function (min, max) {
    return Math.floor(Math.random() * (max - min - 1)) + min;
};

一个名为randFromTill的函数，它接受表示范围的两个数字，并返回一个介于min（含）和max（不含）之间的随机数

var randFromTill = function (min, max) {
    return Math.random() * (max - min) + min;
};

一个名为randFromTo的函数，接受表示范围的两个数字，并返回一个介于min（含）和max（含）之间的随机整数：

var randFromTo = function (min, max) {
    return Math.floor(Math.random() * (max - min + 1)) + min;
};

Mozilla开发者网络页面上有一些示例：

/**
 * Returns a random number between min (inclusive) and max (exclusive)
 */
function getRandomArbitrary(min, max) {
    return Math.random() * (max - min) + min;
}

/**
 * Returns a random integer between min (inclusive) and max (inclusive).
 * The value is no lower than min (or the next integer greater than min
 * if min isn't an integer) and no greater than max (or the next integer
 * lower than max if max isn't an integer).
 * Using Math.round() will give you a non-uniform distribution!
 */
function getRandomInt(min, max) {
    min = Math.ceil(min);
    max = Math.floor(max);
    return Math.floor(Math.random() * (max - min + 1)) + min;
}

这是背后的逻辑。这是一个简单的三条规则：

Math.random（）返回一个介于0（含）和1（不含）之间的数字。所以我们有一个这样的间隔：

[0 .................................... 1)

现在，我们需要一个介于min（含）和max（不含）之间的数字：

[0 .................................... 1)
[min .................................. max)

我们可以使用Math.random获取[min，max）区间的对应值。但是，首先我们应该通过从第二个区间减去min来稍微考虑一下问题：

[0 .................................... 1)
[min - min ............................ max - min)

这给出了：

[0 .................................... 1)
[0 .................................... max - min)

我们现在可以应用Math.random，然后计算对应的。让我们选择一个随机数：

                Math.random()
                    |
[0 .................................... 1)
[0 .................................... max - min)
                    |
                    x (what we need)

因此，为了找到x，我们需要：

x = Math.random() * (max - min);

别忘了把min加回来，这样我们就可以得到[分钟，最大值]间隔内的数字：

x = Math.random() * (max - min) + min;

这是MDN的第一个函数。第二个，返回一个介于min和max之间的整数，两者都包含在内。

现在，对于整数，可以使用round、ceil或floor。

您可以使用Math.round（Math.random（）*（max-min））+min，但这给出了一个非偶数分布。最小值和最大值都只有大约一半的掷骰机会：

min...min+0.5...min+1...min+1.5   ...    max-0.5....max
└───┬───┘└────────┬───────┘└───── ... ─────┘└───┬──┘   ← Math.round()
   min          min+1                          max

如果将最大值排除在区间之外，那么它比最小值滚动的机会更小。

使用Math.floor（Math.random（）*（max-min+1））+min，您可以获得完全均匀的分布。

 min...  min+1...    ...      max-1... max....   (max+1 is excluded from interval)
└───┬───┘└───┬───┘└─── ... ┘└───┬───┘└───┬───┘   ← Math.floor()
   min     min+1               max-1    max

你不能在这个等式中使用ceil（）和-1，因为max现在的掷骰机会稍微少了一些，但你也可以掷（不需要的）min-1的结果。

我制作了这个函数，它考虑了min、max、exclude（要排除的整数列表）和seed（如果您需要种子随机生成器）等选项。

get_random_int = function(args={})
{
    let def_args =
    {
        min: 0,
        max: 1,
        exclude: false,
        seed: Math.random
    }

    args = Object.assign(def_args, args)

    let num = Math.floor(args.seed() * (args.max - args.min + 1) + args.min)

    if(args.exclude)
    {
        let diff = args.max - args.min
        let n = num

        for(let i=0; i<diff*2; i++)
        {
            if(args.exclude.includes(n))
            {
                if(n + 1 <= args.max)
                {
                    n += 1
                }

                else
                {
                    n = args.min
                }
            }

            else
            {
                num = n
                break
            }
        }
    }

    return num
}

它可以像这样使用：

let n = get_random_int
(
    {
        min: 0,
        max: some_list.length - 1,
        exclude: [3, 6, 5],
        seed: my_seed_function
    }
)

或者更简单地说：

let n = get_random_int
(
    {
        min: 0,
        max: some_list.length - 1
    }
)

然后您可以执行以下操作：

let item = some_list[n]

主旨：https://gist.github.com/madprops/757deb000bdec25776d5036dae58ee6e

Use:

function getRandomizer(bottom, top) {
    return function() {
        return Math.floor( Math.random() * ( 1 + top - bottom ) ) + bottom;
    }
}

用法：

var rollDie = getRandomizer( 1, 6 );

var results = ""
for ( var i = 0; i<1000; i++ ) {
    results += rollDie() + " ";    // Make a string filled with 1000 random numbers in the range 1-6.
}

细分：

我们正在返回一个函数（从函数式编程中借用），当调用该函数时，将返回值bottom和top之间的随机整数，包括bottom。我们说“包含”是因为我们希望将底部和顶部都包含在可返回的数字范围内。这样，getRandomizer（1，6）将返回1、2、3、4、5或6。

（“底部”是较低的数字，“顶部”是较大的数字）

Math.random() * ( 1 + top - bottom )

Math.random（）返回一个介于0和1之间的随机双精度，如果我们将其乘以1加上顶部和底部之间的差值，我们将得到一个介于介于0和1+b-a之间的双精度。

Math.floor( Math.random() * ( 1 + top - bottom ) )

Math.floor将数字向下舍入到最接近的整数。所以我们现在有了0和上下之间的所有整数。1看起来很令人困惑，但它需要存在，因为我们总是向下舍入，因此没有它就永远无法到达顶部数字。我们生成的随机小数需要在0到（1+上下）的范围内，这样我们就可以向下舍入，得到0到上下的整数：

Math.floor( Math.random() * ( 1 + top - bottom ) ) + bottom

上一个示例中的代码为我们提供了一个范围为0和上下的整数，因此我们现在需要做的就是将底部添加到该结果中，以获得范围为底部和顶部（含）的整数D

注意：如果你先传入一个非整数值或更大的数字，你会得到不希望的行为，但除非有人要求，否则我不会深入研究参数检查代码，因为它与原始问题的意图相去甚远。