Is there a way to generate a random number in a specified range (e.g. from 1 to 6: 1, 2, 3, 4, 5, or 6) in JavaScript?

# Generate random number between two numbers in JavaScript

### Important

The following code works only if the minimum value is `1`

. It does not work for minimum values other than `1`

.

If you wanted to get a random integer between 1 (**and only 1**) and 6, you would calculate:

```
Math.floor(Math.random() * 6) + 1
```

Where:

- 1 is the start number
- 6 is the number of possible results (1 + start
*(6)*- end*(1)*)

```
function randomIntFromInterval(min, max) { // min and max included
return Math.floor(Math.random() * (max - min + 1) + min);
}
```

What it does "extra" is it allows random intervals that do not start with 1. So you can get a random number from 10 to 15 for example. Flexibility.

# Math.random()

Returns an integer random number between min (included) and max (included):

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

Or any random number between min (included) and max (**not** included):

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

Useful examples (integers):

```
// 0 -> 10
Math.floor(Math.random() * 11);
// 1 -> 10
Math.floor(Math.random() * 10) + 1;
// 5 -> 20
Math.floor(Math.random() * 16) + 5;
// -10 -> (-2)
Math.floor(Math.random() * 9) - 10;
```

** And always nice to be reminded (Mozilla):

Math.random() does not provide cryptographically secure random numbers. Do not use them for anything related to security. Use the Web Crypto API instead, and more precisely the window.crypto.getRandomValues() method.

**TL;DR**

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

To get the random number
`generateRandomInteger(-20, 20);`

**EXPLANATION BELOW**

We need to get a random integer, say **X** between min and max.

Right?

i.e
**min <= X <= max**

If we subtract min from the equation, this is equivalent to

**0 <= (X - min) <= (max - min)**

Now, lets multiply this with a random number **r**
which is

**0 <= (X - min) * r <= (max - min) * r**

Now, lets add back **min** to the equation

**min <= min + (X - min) * r <= min + (max - min) * r**

Now, lets chose a function which results in **r** such that it satisfies our equation range as [min,max]. This is only possible if **0<= r <=1**

OK. Now, the range of **r** i.e [0,1] is very similar to Math.random() function result. Isn't it?

The Math.random() function returns a floating-point, pseudo-random number in the range [0, 1); that is, from 0 (inclusive) up to but not including 1 (exclusive)

For example,

# Case r = 0

`min`

+ 0 * (`max`

-`min`

) = **min**

# Case r = 1

`min`

+ 1 * (`max`

-`min`

) = **max**

# Random Case using Math.random 0 <= r < 1

`min`

+ r * (`max`

-`min`

) = **X**, where **X** has range of **min** <= **X** < **max**

The above result **X** is a random numeric. However due to Math.random() our left bound is inclusive, and the right bound is exclusive. To include our right bound we increase the right bound by 1 and floor the result.

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

# To get the random number

`generateRandomInteger(-20, 20)`

;

Or, in Underscore

```
_.random(min, max)
```

```
var x = 6; // can be any number
var rand = Math.floor(Math.random()*x) + 1;
```

jsfiddle: https://jsfiddle.net/cyGwf/477/

**Random Integer**: to get a random integer between `min`

and `max`

, use the following code

```
function getRandomInteger(min, max) {
min = Math.ceil(min);
max = Math.floor(max);
return Math.floor(Math.random() * (max - min)) + min;
}
```

**Random Floating Point Number**: to get a random floating point number between `min`

and `max`

, use the following code

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

Reference: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/random

Math is not my strong point, but I've been working on a project where I needed to generate a lot of random numbers between both positive and negative.

```
function randomBetween(min, max) {
if (min < 0) {
return min + Math.random() * (Math.abs(min)+max);
}else {
return min + Math.random() * max;
}
}
```

E.g

```
randomBetween(-10,15)//or..
randomBetween(10,20)//or...
randomBetween(-200,-100)
```

Of course, you can also add some validation to make sure you don't do this with anything other than numbers. Also make sure that min is always less than or equal to max.

I wrote more flexible function which can give you random number but not only integer.

```
function rand(min,max,interval)
{
if (typeof(interval)==='undefined') interval = 1;
var r = Math.floor(Math.random()*(max-min+interval)/interval);
return r*interval+min;
}
var a = rand(0,10); //can be 0, 1, 2 (...) 9, 10
var b = rand(4,6,0.1); //can be 4.0, 4.1, 4.2 (...) 5.9, 6.0
```

Fixed version.

Inspite of many answers and almost same result. I would like to add my answer and explain its working. Because it is important to understand its working rather than copy pasting one line code. Generating random numbers is nothing but simple maths.

CODE:

```
function getR(lower, upper) {
var percent = (Math.random() * 100);
// this will return number between 0-99 because Math.random returns decimal number from 0-0.9929292 something like that
//now you have a percentage, use it find out the number between your INTERVAL :upper-lower
var num = ((percent * (upper - lower) / 100));
//num will now have a number that falls in your INTERVAL simple maths
num += lower;
//add lower to make it fall in your INTERVAL
//but num is still in decimal
//use Math.floor>downward to its nearest integer you won't get upper value ever
//use Math.ceil>upward to its nearest integer upper value is possible
//Math.round>to its nearest integer 2.4>2 2.5>3 both lower and upper value possible
console.log(Math.floor(num), Math.ceil(num), Math.round(num));
}
```

I was searching random number generator written in TypeScript and I have written this after reading all of the answers, hope It would work for TypeScript coders.

```
Rand(min: number, max: number): number {
return (Math.random() * (max - min + 1) | 0) + min;
}
```

Adding `float`

with fixed precision version based on the `int`

version in @Francisc's answer:

```
function randomFloatFromInterval (min, max, fractionDigits) {
const fractionMultiplier = Math.pow(10, fractionDigits)
return Math.round(
(Math.random() * (max - min) + min) * fractionMultiplier,
) / fractionMultiplier
}
```

so:

```
randomFloatFromInterval(1,3,4) // => 2.2679, 1.509, 1.8863, 2.9741, ...
```

and for int answer

```
randomFloatFromInterval(1,3,0) // => 1, 2, 3
```

`Math.random()`

is fast and suitable for many purposes, but it's not appropriate if you need cryptographically-secure values (it's not secure), or if you need integers from a completely uniform unbiased distribution (the multiplication approach used in others answers produces certain values slightly more often than others).

In such cases, we can use `crypto.getRandomValues()`

to generate secure integers, and reject any generated values that we can't map uniformly into the target range. This will be slower, but it shouldn't be significant unless you're generating extremely large numbers of values.

To clarify the biased distribution concern, consider the case where we want to generate a value between 1 and 5, but we have a random number generator that produces values between 1 and 16 (a 4-bit value). We want to have the same number of generated values mapping to each output value, but 16 does not evenly divide by 5: it leaves a remainder of 1. So we need to reject 1 of the possible generated values, and only continue when we get one of the 15 lesser values that can be uniformly mapped into our target range. Our behaviour could look like this pseudocode:

```
Generate a 4-bit integer in the range 1-16.
If we generated 1, 6, or 11 then output 1.
If we generated 2, 7, or 12 then output 2.
If we generated 3, 8, or 13 then output 3.
If we generated 4, 9, or 14 then output 4.
If we generated 5, 10, or 15 then output 5.
If we generated 16 then reject it and try again.
```

The following code uses similar logic, but generates a 32-bit integer instead, because that's the largest common integer size that can be represented by JavaScript's standard `number`

type. (This could be modified to use `BigInt`

s if you need a larger range.) Regardless of the chosen range, the fraction of generated values that are rejected will always be less than 0.5, so the expected number of rejections will always be less than 1.0 and usually close to 0.0; you don't need to worry about it looping forever.

```
const randomInteger = (min, max) => {
const range = max - min;
const maxGeneratedValue = 0xFFFFFFFF;
const possibleResultValues = range + 1;
const possibleGeneratedValues = maxGeneratedValue + 1;
const remainder = possibleGeneratedValues % possibleResultValues;
const maxUnbiased = maxGeneratedValue - remainder;
if (!Number.isInteger(min) || !Number.isInteger(max) ||
max > Number.MAX_SAFE_INTEGER || min < Number.MIN_SAFE_INTEGER) {
throw new Error('Arguments must be safe integers.');
} else if (range > maxGeneratedValue) {
throw new Error(`Range of ${range} (from ${min} to ${max}) > ${maxGeneratedValue}.`);
} else if (max < min) {
throw new Error(`max (${max}) must be >= min (${min}).`);
} else if (min === max) {
return min;
}
let generated;
do {
generated = crypto.getRandomValues(new Uint32Array(1))[0];
} while (generated > maxUnbiased);
return min + (generated % possibleResultValues);
};
console.log(randomInteger(-8, 8)); // -2
console.log(randomInteger(0, 0)); // 0
console.log(randomInteger(0, 0xFFFFFFFF)); // 944450079
console.log(randomInteger(-1, 0xFFFFFFFF));
// Error: Range of 4294967296 covering -1 to 4294967295 is > 4294967295.
console.log(new Array(12).fill().map(n => randomInteger(8, 12)));
// [11, 8, 8, 11, 10, 8, 8, 12, 12, 12, 9, 9]
```

Crypto-strong random integer number in range [a,b] (assumption: a < b )

```
let rand= (a,b)=> a+(b-a+1)*crypto.getRandomValues(new Uint32Array(1))[0]/2**32|0
console.log( rand(1,6) );
```

This should work:

```
const getRandomNum = (min, max) => Math.floor(Math.random() * (max - min + 1)) + min
```

I discovered a great new way to do this using ES6 default parameters. It is very nifty since it allows either one argument or two arguments. Here it is:

```
function random(n, b = 0) {
return Math.random() * (b-n) + n;
}
```

to return 1-6 like a dice basically, return Math.round(Math.random() * 5 + 1);

This is about nine years late, but randojs.com makes this a simple one-liner:

```
rando(1, 6)
```

You just need to add this to the head of your html document, and you can do pretty much whatever you want with randomness easily. Random values from arrays, random jquery elements, random properties from objects, and even preventing repetitions if needed.

```
<script src="https://randojs.com/1.0.0.js"></script>
```

This works for me and produces values like Python's random.randint standard library function:

```
function randint(min, max) {
return Math.round((Math.random() * Math.abs(max - min)) + min);
}
console.log("Random integer: " + randint(-5, 5));
```

Try using:

```
function random(min, max) {
return Math.round((Math.random() *( Math.abs(max - min))) + min);
}
console.log(random(1, 6));
```

I found Francisc's solution above did not include the min or max number in the results, so I altered it like this:

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

Works between any two numbers

```
const max = 6, min = 1;
Math.floor(Math.random() * (max - 1)) + min;
```