使用现代JavaScript+Lodash：

const generateRandomNumbers = (max, amount) => {
  const numbers = [...Array(max).keys()];
  const randomNumbers = sampleSize(numbers, amount);

  return randomNumbers.sort((a, b) => a - b);
};

此外，TypeScript版本：

const generateRandomNumbers = (max: number, amount: number) => {
  const numbers = [...Array(max).keys()];
  const randomNumbers: number[] = sampleSize(numbers, amount);

  return randomNumbers.sort((a: number, b: number) => a - b);
};

这是我用来生成随机数的方法。

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

Math.random（）返回一个介于0（含）和1（不含）之间的数字。我们将这个数字乘以范围（max-min）。这将导致一个介于0（含）和范围之间的数字。

例如，随机（2,5）。我们将随机数0≤x<1乘以范围（5-2=3），因此我们现在有一个数x，其中0≤x<3。

为了强制函数将最大值和最小值都视为包含值，我们在范围计算中添加1：Math.random（）*（max-min+1）。现在，我们将随机数乘以（5-2+1=4），得到一个数字x，即0≤x<4。如果我们对这个计算进行下限，我们得到一个整数：0≤x≤3，每个结果的可能性相等（1/4）。

最后，我们需要将其转换为请求值之间的整数。由于我们已经有一个介于0和（max-min）之间的整数，我们可以简单地通过添加最小值将值映射到正确的范围。在我们的示例中，我们将0到3之间的整数加2，得到2到5之间的整数。

我想，这是所有贡献中最简单的。

maxNum = 8,
minNum = 4

console.log(Math.floor(Math.random() * (maxNum - minNum) + minNum))

console.log(Math.floor(Math.random() * (8 - 4) + 4))

这将在控制台中记录4到8之间的随机数，包括4到8。

其他答案没有考虑到0和1这两个完全合理的参数。相反，您应该使用圆形而不是天花板或地板：

function randomNumber(minimum, maximum){
    return Math.round( Math.random() * (maximum - minimum) + minimum);
}

console.log(randomNumber(0,1));  # 0 1 1 0 1 0
console.log(randomNumber(5,6));  # 5 6 6 5 5 6
console.log(randomNumber(3,-1)); # 1 3 1 -1 -1 -1

下面是JavaScript中Random类的Microsoft.NET实现-

var Random = (function () {
    function Random(Seed) {
        if (!Seed) {
            Seed = this.milliseconds();
        }
        this.SeedArray = [];
        for (var i = 0; i < 56; i++)
            this.SeedArray.push(0);
        var num = (Seed == -2147483648) ? 2147483647 : Math.abs(Seed);
        var num2 = 161803398 - num;
        this.SeedArray[55] = num2;
        var num3 = 1;
        for (var i_1 = 1; i_1 < 55; i_1++) {
            var num4 = 21 * i_1 % 55;
            this.SeedArray[num4] = num3;
            num3 = num2 - num3;
            if (num3 < 0) {
                num3 += 2147483647;
            }
            num2 = this.SeedArray[num4];
        }
        for (var j = 1; j < 5; j++) {
            for (var k = 1; k < 56; k++) {
                this.SeedArray[k] -= this.SeedArray[1 + (k + 30) % 55];
                if (this.SeedArray[k] < 0) {
                    this.SeedArray[k] += 2147483647;
                }
            }
        }
        this.inext = 0;
        this.inextp = 21;
        Seed = 1;
    }

    Random.prototype.milliseconds = function () {
        var str = new Date().valueOf().toString();
        return parseInt(str.substr(str.length - 6));
    };

    Random.prototype.InternalSample = function () {
        var num = this.inext;
        var num2 = this.inextp;
        if (++num >= 56) {
            num = 1;
        }
        if (++num2 >= 56) {
            num2 = 1;
        }
        var num3 = this.SeedArray[num] - this.SeedArray[num2];
        if (num3 == 2147483647) {
            num3--;
        }
        if (num3 < 0) {
            num3 += 2147483647;
        }
        this.SeedArray[num] = num3;
        this.inext = num;
        this.inextp = num2;
        return num3;
    };

    Random.prototype.Sample = function () {
        return this.InternalSample() * 4.6566128752457969E-10;
    };

    Random.prototype.GetSampleForLargeRange = function () {
        var num = this.InternalSample();
        var flag = this.InternalSample() % 2 == 0;
        if (flag) {
            num = -num;
        }
        var num2 = num;
        num2 += 2147483646.0;
        return num2 / 4294967293.0;
    };

    Random.prototype.Next = function (minValue, maxValue) {
        if (!minValue && !maxValue)
            return this.InternalSample();
        var num = maxValue - minValue;
        if (num <= 2147483647) {
            return parseInt((this.Sample() * num + minValue).toFixed(0));
        }
        return this.GetSampleForLargeRange() * num + minValue;
    };

    Random.prototype.NextDouble = function () {
        return this.Sample();
    };

    Random.prototype.NextBytes = function (buffer) {
        for (var i = 0; i < buffer.length; i++) {
            buffer[i] = this.InternalSample() % 256;
        }
    };
    return Random;
}());

Use:

var r = new Random();
var nextInt = r.Next(1, 100); // Returns an integer between range
var nextDbl = r.NextDouble(); // Returns a random decimal

我想用一个例子来解释：

函数在JavaScript中生成5到25范围内的随机整数

概述：（i） 首先将其转换为范围-从0开始。（ii）然后将其转换为所需的范围（然后将非常易于完成）。

所以基本上，如果你想生成从5到25的随机整数，那么：

第一步：将其转换为范围-从0开始

从“max”和“min”中减去“lower/minimum number”。即

(5-5) - (25-5)

因此，范围将为：

0-20 ...正确的

第二步

现在，如果您希望两个数字都包含在范围内，即“0和20”，则公式为：

数学方程式：Math.floor（（Math.random（）*21））

一般公式：Math.floor（（Math.random（）*（max min+1）））

现在，如果我们将减去的/最小的数字（即5）添加到范围中，那么我们可以自动获得0到20的范围=>5到25

第三步

现在将减去的差值加在等式（即5）中，并将“Math.floor”添加到整个等式中：

数学方程式：Math.floor（（Math.random（）*21）+5）

一般公式：Math.floor（（Math.random（）*（max-min+1））+min）

因此，最终函数将是：

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