Math.ceil(Math.random() * (range+1))

Math.random() creates a decimal value between 0 and 1, and Math.ceil() rounds it up to the nearest integer.

By multiplying it by a specific number, you create a range of 0..number-1. If you want to generate a random number within the range from num1 to num2, follow this formula:

Math.ceil(Math.random() * (num2-num1 + 1) + num1)

If you need more random numbers, utilize a for loop to store them in an array or output directly to the document.

function getRandomRange(amount, minVal, maxVal) {
    let min = minVal < maxVal ? minVal : maxVal;
    let max = maxVal > minVal ? maxVal : minVal;
    let resultArray = [], randomNumber;
    
    while (amount > 0) {
        randomNumber = Math.round(min + Math.random() * (max - min));
        
        if (resultArray.indexOf(randomNumber) == -1) {
            resultArray.push(randomNumber);
            amount--;
        }
    }
    
    return resultArray;
}

In order to change the method of returning an integer based on the needed range, you can refer to: ceil (a, b], round [a, b], floor [a, b), for (a, b) it is simply a matter of adding 1 to the min with floor.

Generate a random number between 1 and the specified limit: Math.floor(Math.random()*limit)+1

Here is an alternative method to ensure the uniqueness of numbers:

1. Create an array containing all numbers from 0 to x
2. Rearrange the elements in the array randomly
3. Select the first n numbers

This approach, compared to repeatedly generating random numbers until a unique one is found, may use more memory but offers a stable runtime guaranteeing finite results. It is particularly effective when working with lower upper limits or higher amounts to be selected.

In my solution, I utilize the Lodash library for simplicity. However, it is possible to implement the aforementioned algorithm without this library.

// assuming _ represents the Lodash library

// generate `amount` unique numbers ranging from 0 to `upperLimit`
function uniqueRandomInts(upperLimit, amount) {
    var possibleNumbers = _.range(upperLimit + 1);
    var shuffled = _.shuffle(possibleNumbers);
    return shuffled.slice(0, amount);
}

for(x = 0; x <total; x++)
{
    var randNum=Math.floor(Math.random()*max)+1;
    document.write(randNum);
}

Here is an example

var maximum = 15;
var quantity = 6;
var numbers = new Array();

for(let x = 0; x < quantity; x++)
{
    var addNum = true;
    var num = Math.round(Math.random() * maximum + 1);
    for(let y = 0; y < maximum.length; y++)
    {
        if(numbers[y] == num)
        {
            addNum = false;
        }
    }
    if(addNum)
    {
        numbers.push(num)
    }
    else
    {
        x--;
    }
}

function generateRandomNumbers(quantity, ceiling) {
  var randomArray = [],
      memory = {};

  while (randomArray.length < quantity) {
    var number = Math.floor((Math.random() * ceiling) + 1);
    if (!memory[number]) { 
      memory[number] = number; 
      randomArray.push(number); 
    };
  }
  return randomArray; 
}

This code appears to be effective in generating unique random numbers within a specified range.

These responses are lacking in originality, and some are overly complex (one even resorting to using an external library for a simple task).

<sub>1. Generate a random number.
2. If the random number is already generated, go back to 1, otherwise keep it.
3. If the desired quantity of random numbers is not achieved, repeat from step 1.</sub>

function generateUniqueRandoms(quantity, minVal, maxVal){
  var randNum, array=[];
  do { 
    do { 
      randNum = Math.floor(Math.random()*(maxVal-minVal+1))+minVal;
    } while(array.includes(randNum));
    array.push(randNum);
  } while(array.length<quantity);
  return array;
}

//generate 5 unique numbers between 1 and 10
console.log( generateUniqueRandoms(5, 1, 10) );

...and here's a more concise version of the same function:

function generateUniqueRandoms(q,min,max){var a=[];do{do{r=Math.floor(Math.random()*(max-min+1))+min}while(a.includes(r));a.push(r)}while(a.length<q);return a}

/**
 * This function creates an array with random numbers
 * between the specified min and max values.
 */
function generateRandomArray(minValue, maxValue, numOfReplacements){
  var arraySize = (maxValue - minValue) + 1;
  numOfReplacements = numOfReplacements || arraySize;
  var newArray = Array.apply(null, Array(arraySize));

  for(var index = 0, value = minValue; index < arraySize & value <= maxValue; index++, value++) {
    newArray[index] = value;
  }

  for(var swapIndex = 0; swapIndex < numOfReplacements; swapIndex++) {
    var swapIdx1 = Math.round(Math.random() * (arraySize - 1));
    var swapIdx2 = Math.round(Math.random() * (arraySize - 1));

    var temporaryValue = newArray[swapIdx1];
    newArray[swapIdx1] = newArray[swapIdx2];
    newArray[swapIdx2] = temporaryValue;
  }

  return newArray;
}

/* Generating an array and extracting 3 unique numbers from it */
var randomArr = generateRandomArray(1, 10);
for(var count = 0; count < 3; count++) {
  console.log(randomArr.pop());
}

This method takes a very human approach by using a break statement within the while loop. I have elaborated on its working in the comments provided.

function generateRandomUniqueNumbersArray (limit) {

    //We need a place to store these numbers
    const array = new Array();
    //Counter to keep track of valid numbers added
    let counter = 0;

    //Generating random unique numbers until satisfied
    while (true) {

        //Generate a new random number
        const newRandomNumber = Math.floor(Math.random() * limit);

        //Add the number to the array if it's not already there
        if (!array.includes(newRandomNumber)) {
            array.push(newRandomNumber);
            counter++;
        }

        //Stop generating more numbers when the desired count is reached
        if (counter >= limit) {
            break;
        }
    }

    //Return the generated array
    return array;
}

You can adjust the limit in the final 'if' statement to get fewer numbers, but make sure it's less than or equal to the specified limit to avoid an infinite loop.

Discover a potential solution utilizing ES6 Set ("an array that contains only unique values").

Examples of how to use:

// Obtain 4 unique random numbers: from 0 to 4 (inclusive):
getUniqueNumbersInRange(4, 0, 5) //-> [5, 0, 4, 1];

// Obtain 2 unique random numbers: from -1 to 2 (inclusive):
getUniqueNumbersInRange(2, -1, 2) //-> [1, -1];

// Obtain 0 unique random numbers (empty result): from -1 to 2 (inclusive):
getUniqueNumbersInRange(0, -1, 2) //-> [];

// Obtain 7 unique random numbers: from 1 to 7 (inclusive):
getUniqueNumbersInRange(7, 1, 7) //-> [ 3, 1, 6, 2, 7, 5, 4];

The code snippet:

function getUniqueNumbersInRange(uniqueNumbersCount, fromInclusive, untilInclusive) {

    // Step 0/3: Validate inputs.
    if (0 > uniqueNumbersCount) throw new Error('The number of unique numbers cannot be negative.');
    if (fromInclusive > untilInclusive) throw new Error('"From" bound "' + fromInclusive
        + '" cannot be greater than "until" bound "' + untilInclusive + '".');
    const rangeLength = untilInclusive - fromInclusive + 1;
    if (uniqueNumbersCount > rangeLength) throw new Error('The length of the range is ' + rangeLength + '=['
        + fromInclusive + '…' + untilInclusive + '] which is smaller than '
        + uniqueNumbersCount + ' (specified count of result numbers).');
    if (uniqueNumbersCount === 0) return [];


    // Step 1/3: Create a new "Set" – an object that holds unique values.
    const uniqueDigits = new Set();


    // Step 2/3: Populate with random numbers.        
    while (uniqueNumbersCount > uniqueDigits.size) {
        const nextRngNmb = Math.floor(Math.random() * rangeLength) + fromInclusive;
        uniqueDigits.add(nextRngNmb);
    }


    // Step 3/3: Convert "Set" with unique numbers into an array using "Array.from()".
    const resArray = Array.from(uniqueDigits);
    return resArray;

}

The advantages of this implementation:

1. Includes a basic validation of input arguments – preventing unexpected outcomes when the range is too small, etc.
2. Allows for a negative range (not limited to starting from 0), such as generating random numbers from -1000 to 500.
3. Desired behavior: Unlike other solutions, this one does not automatically extend the range if it's too small. For example, requesting 10000 unique numbers within a range from 0 to 10 should trigger an error due to insufficient range (only 11 possible unique numbers). This implementation does not secretly expand the range up to 10000.

A while ago, I crafted this C# script inspired by an algorithm detailed on Wikipedia, although the specifics escape me now (feel free to chime in if you remember!). The uniqueness of values is assured for the duration of the HashSet's existence. If working with a database, it might be wise to save the generated numbers there instead. While the randomness suited my purposes at the time, it could likely benefit from utilizing a different RNG. Important note: the count must not exceed max - min (obviously!) and adjustments can be made to generate ulongs with ease.

private static readonly Random RndGen = new Random();

public static IEnumerable<int> UniqueRandomIntegers(int count, int min, int max)
{
    var rv = new HashSet<int>();
    for (var i = max - min - count + 1; i <= max - min; i++)
    {
       var r = (int)(RndGen.NextDouble() * i);
       var v = rv.Contains(r) ? i : r;
       rv.Add(v);
       yield return v;
    }
}

Shuffled Random Array

Inspired by the response of @rory-okane in this thread, this method generates a randomized array without using lodash.

• The time and space complexity are both O(n) where n=limit

• Consistent runtime performance

• Capable of handling positive or negative number ranges

• In theory, this should support a range from 0 to ±2^32 - 1

  This limitation arises from Javascript arrays only accommodating 2^32 - 1 indexes as specified in the ECMAScript documentation

  I halted testing at 10^8 as my browser started acting up around that point. Strangely, it only accepted negative numbers down to -10^7, throwing an

  Uncaught RangeError: Invalid array length

  error (weird)

• Bonus feature: Generates a randomized array of length n from 0 to limit if only one argument is provided

let uniqueRandomNumbers = (limit, amount = limit) => {
    let array = Array(Math.abs(limit));
    for (let i = 0; i < array.length; i++) array[i] = i * Math.sign(limit);
    let currentIndex = array.length;
    let randomIndex;
    while(currentIndex > 0) {
        randomIndex = Math.floor(Math.random() * currentIndex--);
        [array[currentIndex], array[randomIndex]] = [array[randomIndex], array[currentIndex]];
    }
    return array.slice(0, Math.abs(amount));
}

console.log(uniqueRandomNumbers(10, 3));
console.log(uniqueRandomNumbers(-10, 3));

//bonus feature:
console.log(uniqueRandomNumbers(10));

Credit:

I stumbled upon this solution while attempting to create random arrays of length n. Special thanks to the contributors in these Stack Overflow threads who guided me in finding this approach for my needs today.

• Most efficient way to create a zero filled JavaScript array?
• How to randomize (shuffle) a JavaScript array?
• Additionally, I drew inspiration from the response by @ashleedawg, although I encountered infinite loop issues which led me to the sliced randomized array technique.