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.random() * (max - min + 1)) + min

Why this matters

Random numbers are used in many real programs:

• dice rolls in games
• picking a random item from a list
• generating sample test data
• simple simulations
• randomizing UI elements or content order

Understanding the formula helps you avoid off-by-one errors, which are very common when beginners try to generate numbers in a range.

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 0, 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(1, 6));
console.log(getRandomInt(10, 20));
console.log(getRandomInt(-5, 5));

Random decimal between two numbers

If you want a decimal value instead of an integer:

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

console.log(getRandomNumber(1, 6));

This gives a decimal such as 3.7421 or 5.1189.

Explanation of the integer formula

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

• Math.random() gives a decimal from 0 to < 1
• * (max - min + 1) scales it to the size of the range
• Math.floor() removes the decimal part
• + min shifts the result so it starts at the minimum value

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:

Math.random() === 0.53

4. Scale it to the range size

0.53 * 6 = 3.18

5. Remove the decimal part

Math.floor(3.18) = 3

Now the value is in the range 0 to 5.

6. Shift it up to start at 1

3 + 1 = 4

Final result:

4

So one possible output is 4.

Another example

If Math.random() returns 0.01:

• 0.01 * 6 = 0.06
• Math.floor(0.06) = 0
• 0 + 1 = 1

If Math.random() returns 0.999:

• 0.999 * 6 = 5.994
• Math.floor(5.994) = 5
• 5 + 1 = 6

That is how the formula can produce every number from 1 to 6.

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 = Math.ceil(min);
  max = Math.floor(max);

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

Picking a random array item

A very common real-world use is selecting a random item by index:

const colors = ['red', 'blue', 'green'];
const randomIndex = Math.floor(Math.random() * colors.length);
const randomColor = colors[randomIndex];

Configuration and reuse

Developers often keep ranges configurable:

const config = {
  minDelay: 100,
  maxDelay: 500
};

const delay = Math.floor(Math.random() * (config.maxDelay - config.minDelay + 1)) + config.minDelay;

This makes code easier to adjust without editing the core logic.

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:

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

3. Using Math.round() for ranges

Broken code:

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

This can create uneven probability distribution. Some numbers become more likely than others.

Prefer:

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

4. Confusing inclusive and exclusive ranges

This formula:

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

returns decimals from min up to, but not including, max.

It is not the same as the integer-inclusive formula.

5. Using Math.random() for security

Do not use Math.random() for:

• passwords
• tokens
• secure IDs
• cryptographic values

Use the Web Crypto API instead:

const array = new Uint32Array(1);
crypto.getRandomValues(array);
console.log(array[0]);

6. Not handling reversed input

Broken code:

getRandomInt(10, 1);

Decide how your function should behave:

• throw an error
• swap values
• validate before calling

A safe version throws an error if min > max.

Random number approaches in JavaScript

Math.floor() vs Math.round()

Inclusive vs exclusive ranges

The main choice is simple:

• want decimals: use Math.random() * (max - min) + min
• want integers including both ends: use Math.floor(Math.random() * (max - min + 1)) + min

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, max) {
  min = Math.ceil(min);
  max = Math.floor(max);
  return Math.floor(Math.random() * (max - min + 1)) + min;
}

Rules to remember

• Math.random() never returns 1
• Math.floor() is the usual choice for integer ranges
• add + 1 when you want the maximum included
• do not use Math.round() for fair random integer ranges
• do not use Math.random() for security-sensitive values

Common example

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

Edge cases

• If min === max, the result will always be that number.
• If min > max, validate or throw an error.
• If inputs are decimals, decide whether to allow decimal output or convert to integers first.

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 + 1 makes the maximum reachable.

Can I generate a random decimal instead of an integer?

Yes:

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

This gives a decimal between min and max, with max excluded.

Is Math.random() truly random?

It is pseudo-random, which is good enough for many everyday programming tasks, but not for cryptographic security.

Should I use Math.random() for passwords or secure tokens?

No. Use a cryptographically secure API such as crypto.getRandomValues() instead.

• 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.