How to Generate Random Numbers in JavaScript

Random numbers are essential in programming, whether you’re building games, simulations, quizzes, or generating unique identifiers. JavaScript provides built-in methods to create random numbers, integers, booleans, and even shuffle arrays. In this guide, we’ll cover everything from basic javascript random number to advanced randomization techniques, complete with code examples.

Basics of Generating a Random Number in JavaScript

In JavaScript, the primary method for generating random numbers is Math.random(). This method returns a floating-point random number between 0 (inclusive) and 1 (exclusive). This means it will return a value in the range [0, 1), like 0.2345 or 0.6789. It’s as simple as that! Let’s check a code sample for this:

javascript
let randomNum = Math.random();
console.log(randomNum); // Outputs a random number between 0 and 1

This would give an output like this, if we ran the program on our systems:

Although, this is a great starting point, but if we need a random integer or a number in a specific range, Math.random() alone won’t be enough to do the job.

Generating Random Numbers in a Specific range

To generate a random number in a specific range, say between a particular min value and another particular max value, you’ll need to do a bit of math. Here’s a formula that will help:

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

console.log(getRandomInRange(10, 20)); // Outputs a number between 10 and 20

This would give an output like:

The Math.random() generates a number between 0 and 1. And, by multiplying it with (max - min) and then adding min, you ensure the number falls within the range [min, max).

Generating Random Integers in a Javascript

Sometimes, you may need a whole number instead of a floating-point value. To generate random integers in a specific range, you can use Math.floor() or Math.ceil(). Let’s check how:

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

console.log(getRandomIntInRange(1, 100)); // Outputs a random integer between 1 and 100

When we run this code, we will get a similar output like this:

Here, Math.floor() rounds down to the nearest integer, ensuring the result is an integer within the range [min, max].

Generating Random Booleans values

You can also generate random boolean values (true or false) in JavaScript, which can be useful in games or in any scenario of decision-making:

javascript
function getRandomBoolean() {
  return Math.random() >= 0.5;
}

console.log(getRandomBoolean()); // Outputs true or false randomly

We’ll get a similar output like this, when we will run the code:

Generating Random Values from an Array

Now, if we want to select a random element from an array, we can easily use Math.floor() with Math.random(). Let’s see how we can do that:

javascript
const colors = ["red", "green", "blue", "yellow"];
const randomColor = colors[Math.floor(Math.random() * colors.length)];
console.log(randomColor); // Outputs a random color from the array

Now, this will give us any random element from the array like this, when we run the program:

Shuffling an Array in Javascript

To shuffle an array, i.e. randomly rearrange its elements, you can use the Fisher-Yates shuffle algorithm. Here’s how it can be implemented with the help of Math.random():

javascript
function shuffleArray(array) {
  for (let i = array.length - 1; i > 0; i--) {
    const j = Math.floor(Math.random() * (i + 1));
    [array[i], array[j]] = [array[j], array[i]];
  }
  return array;
}

const numbers = [1, 2, 3, 4, 5];
console.log(shuffleArray(numbers)); // Outputs a shuffled array

Now, when we’ll run the program, it will give us a shuffled array like this:

Generating Random UUID Generation

In a lot of development scenarios, you might need to use unique identifiers, and you might consider using a random UUID (Universally Unique Identifier). Here’s a basic example of a UUID generator using our random method:

javascript
function generateUUID() {
  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
    const r = Math.random() * 16 | 0;
    const v = c === 'x' ? r : (r & 0x3 | 0x8);
    return v.toString(16);
  });
}

console.log(generateUUID()); // Outputs a random UUID

So, when we run this program, it will generate a random UUID like this:

Generating Cryptographically Secure Random Numbers

While Math.random() works for most use cases, it is not suitable for cryptographic purposes like generating passwords, tokens, or secure keys because it’s predictable.

For security-critical applications, you should use the Web Cryptography API:

javascript
function getSecureRandom() {
  const array = new Uint32Array(1);
  window.crypto.getRandomValues(array);
  return array[0];
}

console.log(getSecureRandom()); // Outputs a cryptographically secure random number

Use crypto.getRandomValues() whenever you need unpredictable and secure randomness.

Conclusion

JavaScript offers a versatile set of tools for working with random numbers. From simple Math.random() calls to generating integers, booleans, shuffling arrays, or creating UUIDs, these techniques allow you to add unpredictability to your projects. Practice these methods in real-world scenarios like games, simulations, or random quizzes to truly master randomness in JavaScript.

Further Readings

https://keploy.io/blog/technology/mastering-nyc-enhance-javascript-typescript-test-coverage

https://keploy.io/blog/community/javascript-var-vs-let-vs-const

Frequently Asked Questions

Is Math.random() truly random?

No, Math.random() is not truly random. It is a pseudo-random number generator (PRNG), which means it uses a deterministic algorithm to generate numbers. While these numbers may appear random, they are generated by a predictable process.

Can I set a seed for Math.random() in JavaScript?

JavaScript’s Math.random() does not allow you to set a seed natively. Some other programming languages allow seeded random number generators for reproducibility, but in JavaScript, you’ll need a third-party library (such as seedrandom) if you want this feature.

Why does Math.random() return a number between 0 and 1, instead of a larger range?

The design choice behind Math.random() returning a floating-point number between 0 and 1 is to provide flexibility. By returning a normalized value, developers can easily scale it to any range or format, such as integers or numbers between a specific min and max.

Are there any performance concerns with using Math.random() frequently?

In most cases, Math.random() is efficient and fast enough for regular use, such as in games, animations, or other everyday applications. However, if you need to generate millions of random numbers in real-time (for example, in high-performance simulations), you might want to consider optimized solutions like WebAssembly-based random generators or custom algorithms.

Can Math.random() be used for cryptographic purposes?

No, Math.random() is not secure enough for cryptographic purposes. It is predictable and should not be used in situations that require secure random numbers, like generating passwords or cryptographic keys. For these scenarios, you should use the crypto.getRandomValues() method provided by the Web Cryptography API, which offers more secure randomness.