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

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

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

您可以使用此代码段，

let randomNumber = function(first, second) {
    let number = Math.floor(Math.random()*Math.floor(second));
    while(number < first) {

        number = Math.floor(Math.random()*Math.floor(second));
    }
    return number;
}

使用计算机程序生成随机数后，如果选取的数字是初始数字的一部分或全部，则仍将其视为随机数。但如果它被改变了，数学家就不接受它是一个随机数，他们可以称它为一个有偏数。

但是，如果您正在为一项简单的任务开发一个程序，则不需要考虑这种情况。但是，如果你正在开发一个程序，为有价值的东西（如彩票程序或赌博游戏）生成随机数，那么如果你不考虑上述情况，你的程序将被管理层拒绝。

所以对于这类人，我的建议是：

使用Math.random（）生成一个随机数（说这个n）：

Now for [0,10) ==>  n*10 (i.e. one digit) and for[10,100) ==> n*100 (i.e., two digits) and so on. Here square bracket indicates that the boundary is inclusive and a round bracket indicates the boundary is exclusive.

然后删除小数点后的其余部分。（即，获得发言权）-使用Math.floor（）。这可以完成。

如果你知道如何读取随机数表来选择一个随机数，那么你知道上面的过程（乘以1、10、100等）不会违反我在开头提到的过程（因为它只改变小数点的位置）。

研究以下示例，并根据您的需要进行开发。

如果你需要一个样本[0,9]，那么n10的下限是你的答案，如果你需要[0,99]，那么n100的下限就是你的答案等等。

现在让我们进入您的角色：

您已要求提供特定范围内的数字。（在这种情况下，你在这个范围内是有偏差的。通过掷骰子从[1,6]中取一个数字，那么你就有偏差到[1,6]，但当且仅当骰子无偏差时，它仍然是一个随机数。）

所以考虑一下你的范围==>[78，247]范围内的元素数=247-78+1=170；（因为两个边界都包含在内）。

/* Method 1: */
    var i = 78, j = 247, k = 170, a = [], b = [], c, d, e, f, l = 0;
    for(; i <= j; i++){ a.push(i); }
    while(l < 170){
        c = Math.random()*100; c = Math.floor(c);
        d = Math.random()*100; d = Math.floor(d);
        b.push(a[c]); e = c + d;
        if((b.length != k) && (e < k)){  b.push(a[e]); }
        l = b.length;
    }
    console.log('Method 1:');
    console.log(b);

/* Method 2: */

    var a, b, c, d = [], l = 0;
    while(l < 170){
        a = Math.random()*100; a = Math.floor(a);
        b = Math.random()*100; b = Math.floor(b);
        c = a + b;
        if(c <= 247 || c >= 78){ d.push(c); }else{ d.push(a); }
        l = d.length;
    }
    console.log('Method 2:');
    console.log(d);

注意：在方法一中，首先我创建了一个包含所需数字的数组，然后将它们随机放入另一个数组中。

在方法二中，随机生成数字，并检查这些数字是否在您需要的范围内。然后将其放入数组中。在这里，我生成了两个随机数，并使用它们的总数通过最小化获得有用数字的失败率来最大化程序的速度。然而，将生成的数字相加也会产生一些偏差。所以我推荐我的第一种方法来生成特定范围内的随机数。

在这两种方法中，控制台都会显示结果（在Chrome中按F12打开控制台）。

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的结果。

这是我对一个范围内的随机数的看法，就像我想得到一个基数到指数范围内的一个随机数。例如，基数=10，指数=2，理想情况下给出从0到100的随机数，依此类推。

如果它有助于使用它，这里是：

// Get random number within provided base + exponent
// By Goran Biljetina --> 2012

function isEmpty(value) {
    return (typeof value === "undefined" || value === null);
}

var numSeq = new Array();

function add(num, seq) {
    var toAdd = new Object();
    toAdd.num = num;
    toAdd.seq = seq;
    numSeq[numSeq.length] = toAdd;
}

function fillNumSeq (num, seq) {
    var n;
    for(i=0; i<=seq; i++) {
        n = Math.pow(num, i);
        add(n, i);
    }
}

function getRandNum(base, exp) {
    if (isEmpty(base)) {
        console.log("Specify value for base parameter");
    }
    if (isEmpty(exp)) {
        console.log("Specify value for exponent parameter");
    }

    fillNumSeq(base, exp);

    var emax;
    var eseq;
    var nseed;
    var nspan;
    emax = (numSeq.length);
    eseq = Math.floor(Math.random()*emax) + 1;
    nseed = numSeq[eseq].num;
    nspan = Math.floor((Math.random())*(Math.random()*nseed)) + 1;
    return Math.floor(Math.random()*nspan) + 1;
}

console.log(getRandNum(10, 20), numSeq);

//Testing:
//getRandNum(-10, 20);
//console.log(getRandNum(-10, 20), numSeq);
//console.log(numSeq);

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

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