 # Recipes for Randomness in JavaScript

Random behaviour is often required in JavaScript, from drawing stars scattered across the night sky to animating chaotic attractors. But there are many different kinds of randomness, and the type you need will differ depending on the application.

## Basic Randomness

The simplest form of randomness is the `Math.random()` function built into JavaScript. In the console:

``````> Math.random()
0.19401081069372594``````

`Math.random()` always returns a floating-point number between 0 and 1.

Because it’s so frequently used, `Math.random()` is often placed inside its own function in a script:

``````function getRandom() {
return Math.random();
}``````

The problem, of course, is that the function will always create a random number within a very limited range; most of the other code recipes on this page are designed to address this.

## Randomness Between Numbers: Min Included, Max Excluded

Extending this functionality requires a little bit of math:

### Floating Point

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

### Integer

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

getRandomInt(10, 20)
> 12``````

## Random Integer In Range, Both Min & Max Included

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

getRandomInRange(1, 10)
> 7``````

## Coin Toss (Random True / False)

If you want a simple random 0 or 1 to represent a coin toss:

``````function coinToss() {
return Math.floor(Math.random() * 2);
}
coinToss();
> 0``````

If you prefer actual `true` and `false` values:

``````function coinToss() {
return (Math.floor(Math.random() * 2) === 0);
}
coinToss();
> true``````

Or alternatively:

``````function coinToss() {
Math.random()<.5;
}
coinToss();``````

Or if you want to associate any other words with the coin sides ( yes / no, heads / tails, etc):

``````function coinFlip() {
return (Math.floor(Math.random() * 2) === 0) ? "up" : "down";
}
coinToss();
> up``````

## Random With Exclusions

For a limited range of integers: create an array of numbers that you’d like to draw from and select randomly from the array:

``````var numPool = [ 1, 3, 5, 7, 9, 10 ],
rand = numPool[Math.floor(Math.random() * numPool.length)];``````

For something a little more dynamic: add an array of the numbers you want to exclude, and an empty array to contain the result of filtering the first array into the second:

``````var numPool = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];
var excludePool = [ 3, 4 ];
var filteredPool = [];``````

Then loop through the `numPool` array, test if the number drawn from the array exists in `excludePool`, and place the result in `filteredPool`:

``````for (var i = 0; i < numPool.length; i++) {
if (excludePool.indexOf(numPool[i]) === -1) {
filteredPool.push(numPool[i]);
}
}``````

Finally, draw a random number from `filteredPool`:

``var rand = filteredPool[Math.floor(Math.random() * filteredPool.length)];``

## Random, Non-Repeating

For a small set of numbers: create an array filled with elements, shuffle them randomly, put the results into a new array, then `pop` out the shuffled elements one at a time:

``````var numPool = [ 13, 21, 36, 14, 27, 10 ];

function shuffle(numPool) {
for(var j, x, i = numPool.length; i; j = parseInt(Math.random() * i), x = numPool[--i], numPool[i] = numPool[j], numPool[j] = x);
return numPool;
};
var randomResult = shuffle(numPool);
while( randomResult.length > 0 ) {
console.log( randomResult.pop() );
}``````

For a larger set of numbers, create and fill the array with random integers, rejecting any that have been previously generated:

``````var numReserve = []
while (numReserve.length < 12) {
var randomNumber = Math.ceil(Math.random() * 1000);
var found = false;
for (var i = 0; i < numReserve.length; i++) {
if (numReserve[i] === randomNumber){
found = true;
break;
}
}
if (!found) { numReserve[numReserve.length]=randomNumber; }
}``````

In the code above, `numReserve` is filled with 12 random numbers between 0 and 1000; the numbers can then be lifted from the array.

## Cryptographic Randomness

None of these methods create numbers with enough randomness for cryptographically secure functions (and arguably, `Math.random()` isn’t nearly random enough). For those, we can use the Web Cryptography API by creating a `typedArray`:

``var cryptoStor = new Uint16Array(8);``

(In this case, we’re creating an array with eight different slots that can each contain an unsigned 16-bit integer. Other interger options include `Int8Array`, `Uint8Array`, `int16Array`, `Int32Array` and `Uint32Array`.

Then, fill the array with random numbers of the defined type:

``window.crypto.getRandomValues(cryptoStor);``

Showing the collected values in the console:

``> [43484, 57947, 46691, 49849, 24272, 11827, 28203, 17423]``

The Web Cryptography API has good support in modern browsers, although it is vendor prefixed in some cases.

Image by Philippe Put, used under a Creative Commons license