Skip to main content

How to Get a Random Float within a Range in JavaScript

Generating a random floating-point number (a decimal) within a specific range is a common task in programming, useful for simulations, testing, and creating dynamic data. JavaScript's Math.random() function is the key to this, but it must be combined with some simple arithmetic to produce a number within your desired range.

This guide will teach you how to create a reusable function to generate a random float between a minimum and maximum value. You will also learn how to round the result to a specific number of decimal places.

The Core Logic: Scaling Math.random()​

The Math.random() function is the foundation of this process, but it only returns a random decimal between 0 (inclusive) and 1 (exclusive). To make this useful, we need to scale and shift this value to fit our range.

The logic is as follows:

  1. Calculate the Range: Find the difference between your max and min values.
  2. Scale Math.random(): Multiply the result of Math.random() by this range. This gives you a random value that is somewhere between 0 and the size of your range.
  3. Shift the Range: Add your min value to this result. This shifts the scaled number up so that it starts from your desired minimum.

The formula is: Math.random() * (max - min) + min

The Reusable Function (Best Practice)​

For clean and maintainable code, you should encapsulate this logic in a reusable function.

For example, we want to generate a random floating-point number between 1.5 and 3.5.

Solution:

/**
 * Generates a random floating-point number within a specified range.
 * @param {number} min The minimum value (inclusive).
 * @param {number} max The maximum value (exclusive).
 * @returns {number} A random float within the range.
 */
function getRandomFloat(min, max) {
  return Math.random() * (max - min) + min;
}

// Example Usage:
console.log(getRandomFloat(1.5, 3.5)); // Output: (e.g.) 2.5369...
console.log(getRandomFloat(0, 10));    // Output: (e.g.) 7.3148...

How to Round to a Specific Number of Decimal Places​

The function above returns a float with many decimal places. Often, you need to round this to a specific precision (e.g., two decimal places for currency). The toFixed() method is perfect for this, but it's important to remember that it returns a string.

For example, we want a random float between 1.5 and 3.5, but rounded to exactly two decimal places.

The solutions is an enhanced function that adds a decimals parameter.

function getRandomFloat(min, max, decimals) {
  const str = (Math.random() * (max - min) + min).toFixed(decimals);
  
  return parseFloat(str);
}

// Example Usage:
console.log(getRandomFloat(1.5, 3.5, 2)); // Output: (e.g.) 2.84
console.log(getRandomFloat(1.5, 3.5, 4)); // Output: (e.g.) 2.6455

How it works:

  1. We first generate the random float as before.
  2. .toFixed(decimals): This method formats the number to the specified number of decimal places and returns it as a string.
  3. parseFloat(str): We then use parseFloat() to convert the formatted string back into a number.

Conclusion​

Generating a random float within a range is a simple task once you understand the core mathematical formula.

  • The standard formula is Math.random() * (max - min) + min.
  • The best practice is to place this logic inside a reusable function.
  • If you need to round the result to a specific precision, use the .toFixed() method to format the number and then parseFloat() to convert it back to the number type.

Table of Contents