# 在 JavaScript 中生成两个数字之间的随机数

``````function randomIntFromInterval(min, max) { // min and max included
return Math.floor(Math.random() * (max - min + 1) + min)
}
``````const rndInt = randomIntFromInterval(1, 6)
console.log(rndInt)``````

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.

Other solutions:

• `(Math.random() * 6 | 0) + 1`
• `~~(Math.random() * 6) + 1`

Try online

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)
``````
``</div>``

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;
}
``````

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 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;
}
``````
``</div>``

`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}) &gt; \${maxGeneratedValue}.);
} else if (max < min) {
throw new Error(max (\${max}) must be &gt;= 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]``````

``</div>``