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

Enjoy this piece? I invite you to follow me at twitter.com/dudleystorey to learn more.