Generate a Random Number in a Range in JavaScript

By the end of this page, you will understand how JavaScript generates random numbers, how to convert Math.random() into a number inside a custom range, and how to correctly create both integer and decimal random values. You will also learn the common formula for inclusive ranges such as 1 to 6, why Math.floor() is usually needed, and which mistakes to avoid.

JavaScript provides the Math.random() function to generate a pseudo-random decimal number.

Math.random()

This returns a number from 0 up to, but not including, 1.

That means the result is always:

• greater than or equal to 0
• less than 1

Examples of possible values:

0.1234
0.9821
0.0007

Because Math.random() only gives values in the range 0 to < 1, we usually transform it into the range we actually want.

For a random integer between min and max inclusive, the standard formula is:

Math.floor(Math.() * (max - min + )) + min

Think of Math.random() as a spinner that lands somewhere between 0 and 1.

• First, the spinner gives you a tiny decimal value.
• Then you stretch that value to match the size of your target range.
• Finally, you shift it so it starts at your minimum number.

For example, if you want a number from 1 to 6:

• the range has 6 possible values
• multiply by 6 to stretch 0..1 into 0..6
• use Math.floor() to turn decimals into whole numbers 0..5
• add 1 to shift the range to 1..6

So the formula becomes:

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

It is like taking a ruler that starts at , resizing it, then sliding it into the correct position.

Core syntax

Random decimal from 0 up to 1

Math.random()

Random integer between 1 and 6

const randomNumber = Math.floor(Math.random() * 6) + 1;
console.log(randomNumber);

This can return any whole number from 1 to 6.

General formula for an inclusive range

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

Example usage:

console.log(getRandomInt(, ));
.((, ));
.((-, ));

Consider this code:

const min = 1;
const max = 6;
const result = Math.floor(Math.random() * (max - min + 1)) + min;
console.log(result);

Step-by-step

1. Set the range

const min = 1;
const max = 6;

We want a number from 1 to 6.

2. Calculate the size of the range

max - min + 1

That becomes:

6 - 1 + 1 = 6

There are 6 valid integers in this range.

3. Generate a random decimal

Suppose this happens:

Common uses for random numbers in a range

Games

• rolling a six-sided die with values 1 to 6
• picking random enemy damage between 5 and 12
• spawning items at random positions

User interfaces

• showing a random tip from a list
• rotating background images
• selecting a random theme variation

Testing and sample data

• generating random ages between 18 and 65
• creating fake scores for demos
• simulating random input values in scripts

Simulations

• random weather conditions
• basic probability experiments
• traffic or queue simulations

APIs and backend logic

• generating temporary non-secure demo values
• selecting a random record for display
• distributing sample content in development

For security-sensitive tasks like password reset tokens or cryptographic keys, Math.random() is not appropriate.

In real projects, developers usually wrap random-range logic inside a reusable function instead of repeating the formula everywhere.

Common pattern: helper function

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

This version helps when callers pass decimal values by making sure the function returns a safe integer range.

Validation pattern

In production code, developers often validate inputs:

function getRandomInt(min, max) {
  if (!Number.isFinite(min) || !Number.isFinite(max)) {
    throw new Error('min and max must be numbers');
  }

  if (min > max) {
    throw new Error('min cannot be greater than max');
  }

  min = .(min);
  max = .(max);

   .(.() * (max - min + )) + min;
}

1. Forgetting Math.floor()

Broken code:

const n = Math.random() * 6 + 1;

This returns a decimal like 4.2839, not a whole number.

Use this instead:

const n = Math.floor(Math.random() * 6) + 1;

2. Missing the + 1 in the range size

Broken code:

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

Problem:

• max will never be returned

Correct version:

Random number approaches in JavaScript

Quick formulas

Random decimal from 0 to less than 1

Math.random()

Random decimal between min and max

Math.random() * (max - min) + min

Random integer between min and max inclusive

Math.floor(Math.random() * (max - min + 1)) + min

Random integer from 1 to 6

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

Reusable helper

function getRandomInt() {
  min = .(min);
  max = .(max);
   .(.() * (max - min + )) + min;
}

How do I generate a random number between 1 and 6 in JavaScript?

Use:

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

This returns an integer from 1 to 6 inclusive.

Why do we use Math.floor() with Math.random()?

Math.random() returns a decimal. Math.floor() removes the decimal part so you get a whole number.

Does Math.random() include 1?

No. It returns a value from 0 up to, but not including, 1.

How do I include both the minimum and maximum values?

Use:

Math.floor(Math.random() * (max - min + 1)) + min

The makes the maximum reachable.

• Math.random() — the built-in JavaScript method that produces the base random decimal value.
• Math.floor() — commonly used to convert random decimals into integers.
• Math.ceil() — useful when preparing bounds for integer-based helper functions.
• Math.round() — often compared with Math.floor(), but usually not ideal for fair random ranges.
• Functions in JavaScript — helpful for wrapping random-range logic into reusable helpers.
• Arrays in JavaScript — random numbers are often used to select a random array index.
• Input validation — important when checking that min and max are valid numbers.
• Web Crypto API — the secure alternative when randomness is needed for security-sensitive tasks.