Создание случайного числа между двумя номерами в JavaScript

Есть ли способ генерировать случайное число в указанном диапазоне (например, от 1 до 6: 1, 2, 3, 4, 5 или 6) в JavaScript?

+1543
10 февр. '11 в 16:41
источник поделиться
22 ответа

Важный

Следующий код работает, только если минимальное значение равно 1. Это не работает для минимальных значений, кроме 1.

Если вы хотите получить случайное целое число от 1 (и только 1) до 6, вы должны вычислить:

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

Куда:

  • 1 - начальный номер
  • 6 - количество возможных результатов (1 + начало (6) - конец (1))
+1895
10 февр. '11 в 16:45
источник

Связанные вопросы


Похожие вопросы

function randomIntFromInterval(min,max) // min and max included
{
    return Math.floor(Math.random()*(max-min+1)+min);
}

То, что он делает "дополнительно", это то, что он допускает случайные интервалы, которые не начинаются с 1. Таким образом, вы можете получить случайное число от 10 до 15, например. Гибкость.

+1958
29 авг. '11 в 9:25
источник

Math.random()

Из документации Mozilla Developer Network:

// Returns a random integer between min (include) and max (include)

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

Полезные примеры:

// 0 -> 10
Math.floor(Math.random() * 11);

// 1 -> 10
Math.floor(Math.random() * 10) + 1;

// 5 -> 20
Math.floor(Math.random() * 16) + 5;

// -10 -> (-2)
Math.floor(Math.random() * 9) - 10;
+249
11 июн. '14 в 0:23
источник

Другие решения:

  • (Math.random() * 6 | 0) + 1
  • ~~(Math.random() * 6) + 1
+82
09 нояб. '11 в 10:08
источник

TL; DR

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

Чтобы получить случайное число generateRandomInteger(-20, 20);

ОБЪЯСНЕНИЕ НИЖЕ

Нам нужно получить случайное целое число, скажем, X между min и max.

Правильно?

то есть min <= X <= max

Если вычесть мин из уравнения, это эквивалентно

0 <= (X - min) <= (max - min)

Теперь давайте умножим это на случайное число r, которое

0 <= (X - мин) * r <= (макс - мин) * r

Теперь давайте вернем мин в уравнение

min <= min + (X - min) * r <= min + (max - min) * r

Теперь давайте выберем функцию, которая приводит к r так, что она удовлетворяет диапазону наших уравнений как [min, max]. Это возможно только если 0 <= r <= 1

ХОРОШО. Теперь диапазон r ie [0,1] очень похож на результат функции Math.random(). Не так ли?

Функция Math.random() возвращает псевдослучайное число с плавающей точкой в диапазоне [0, 1); то есть от 0 (включительно) до, но не включая 1 (исключая)

Например,

Случай г = 0

min + 0 * (max - min) = мин

Случай г = 1

min + 1 * (max - min) = макс

Случайный случай с использованием Math.random 0 <= r <1

min + r * (max - min) = X, где X имеет диапазон min <= X < max

Приведенный выше результат X является случайным числом. Однако благодаря Math.random() наша левая граница является включающей, а правая - исключительной. Чтобы включить нашу правую границу, мы увеличиваем правую границу на 1 и получаем результат.

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

Чтобы получить случайное число

generateRandomInteger(-20, 20);

+47
03 апр. '17 в 11:45
источник

Или в Underscore

_.random(min, max)
+20
03 окт. '14 в 1:52
источник

jsfiddle: https://jsfiddle.net/cyGwf/477/

Случайное целое: чтобы получить случайное целое число между min и max, используйте следующий код

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

Случайный номер плавающей запятой: чтобы получить случайное число с плавающей запятой между min и max, используйте следующий код

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

Ссылка: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/random

+19
25 янв. '17 в 4:33
источник
var x = 6; // can be any number
var rand = Math.floor(Math.random()*x) + 1;
+19
10 февр. '11 в 16:46
источник

Математика не моя сильная сторона, но я работал над проектом, где мне нужно было генерировать множество случайных чисел между положительными и отрицательными.

function randomBetween(min, max) {
    if (min < 0) {
        return min + Math.random() * (Math.abs(min)+max);
    }else {
        return min + Math.random() * max;
    }
}

Например,

randomBetween(-10,15)//or..
randomBetween(10,20)//or...
randomBetween(-200,-100)

Конечно, вы также можете добавить некоторую проверку, чтобы убедиться, что вы не делаете этого ни с чем, кроме цифр. Также убедитесь, что min всегда меньше или равно max.

+13
20 мар. '13 в 21:23
источник

Я написал более гибкую функцию, которая может дать вам случайное число, но не только целое число.

function rand(min,max,interval)
{
    if (typeof(interval)==='undefined') interval = 1;
    var r = Math.floor(Math.random()*(max-min+interval)/interval);
    return r*interval+min;
}

var a = rand(0,10); //can be 0, 1, 2 (...) 9, 10
var b = rand(4,6,0.1); //can be 4.0, 4.1, 4.2 (...) 5.9, 6.0

Фиксированная версия.

+8
10 мая '15 в 20:14
источник

пример

Вернуть случайное число от 1 до 10:

Math.floor((Math.random() * 10) + 1);

Результат может быть: 3

Попробуйте сами: здесь

-

или используя lodash/undescore:

_.random(min, max)

Документы: - lodash - undescore

+6
30 апр. '16 в 18:05
источник

Несмотря на множество ответов и почти такой же результат. Я хотел бы добавить свой ответ и объяснить его работу. Потому что важно понимать его работу, а не копировать один код строки. Генерация случайных чисел - не что иное, как простая математика.

CODE:

function getR(lower, upper) {

  var percent = (Math.random() * 100);
  // this will return number between 0-99 because Math.random returns decimal number from 0-0.9929292 something like that
  //now you have a percentage, use it find out the number between your INTERVAL :upper-lower 
  var num = ((percent * (upper - lower) / 100));
  //num will now have a number that falls in your INTERVAL simple maths
  num += lower;
  //add lower to make it fall in your INTERVAL
  //but num is still in decimal
  //use Math.floor>downward to its nearest integer you won't get upper value ever
  //use Math.ceil>upward to its nearest integer upper value is possible
  //Math.round>to its nearest integer 2.4>2 2.5>3   both lower and upper value possible
  console.log(Math.floor(num), Math.ceil(num), Math.round(num));
}
+5
15 янв. '17 в 5:44
источник

Я искал генератор случайных чисел, написанный в TypeScript, и я написал это после прочтения всех ответов, надеюсь, что он будет работать для кодеров TypeScript.

    Rand(min: number, max: number): number {
        return (Math.random() * (max - min + 1) | 0) + min;
    }   
+4
07 сент. '14 в 14:14
источник

Добавление float с версией с фиксированной точностью, основанной на версии int в ответе @Francisc:

function randomFloatFromInterval (min, max, fractionDigits) {
  const fractionMultiplier = Math.pow(10, fractionDigits)
  return Math.round(
    (Math.random() * (max - min) + min) * fractionMultiplier,
  ) / fractionMultiplier
}

так:

randomFloatFromInterval(1,3,4) // => 2.2679, 1.509, 1.8863, 2.9741, ...

и для int ответа

randomFloatFromInterval(1,3,0) // => 1, 2, 3
+3
13 февр. '19 в 13:34
источник

Смысл вам нужно добавить 1 к максимальному числу, а затем вычесть минимальное число для любого из них, чтобы работать, и мне нужно сделать много случайных целых чисел, эта функция работает.

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

Это работает как с отрицательными, так и с положительными числами, и я работаю над десятичными знаками для библиотеки.

+2
31 янв. '15 в 21:36
источник

Math.random() быстр и подходит для многих целей, но он не подходит, если вам нужны криптографически безопасные значения (небезопасные) или если вам нужны целые числа из абсолютно равномерного несмещенного распределения (подход умножения, используемый в других ответах, дает некоторые значения немного чаще, чем другие).

В таких случаях мы можем использовать crypto.getRandomValues() для генерации безопасных целых чисел и отклонения любых сгенерированных значений, которые мы не можем равномерно отобразить в целевой диапазон. Это будет медленнее, но это не должно быть значительным, если вы не генерируете очень большое количество значений.

Чтобы прояснить проблему смещенного распределения, рассмотрим случай, когда мы хотим сгенерировать значение от 1 до 5, но у нас есть генератор случайных чисел, который выдает значения от 1 до 16 (4-битное значение). Мы хотим иметь одинаковое количество сгенерированных значений, сопоставляемых с каждым выходным значением, но 16 не делится поровну на 5: остается остаток от 1. Поэтому нам нужно отклонить 1 из возможных сгенерированных значений и продолжить только тогда, когда мы получим одно из 15 меньших значений, которые могут быть равномерно отображены в нашем целевом диапазоне. Наше поведение может выглядеть следующим образом:

Generate a 4-bit integer in the range 1-16.
If we generated  1,  6, or 11 then output 1.
If we generated  2,  7, or 12 then output 2.
If we generated  3,  8, or 13 then output 3.
If we generated  4,  9, or 14 then output 4.
If we generated  5, 10, or 15 then output 5.
If we generated 16 then reject it and try again.

В следующем коде используется аналогичная логика, но вместо этого генерируется 32-разрядное целое число, поскольку это самый большой общий целочисленный размер, который может быть представлен стандартным number типом JavaScript. (Это можно изменить, чтобы использовать BigInt если вам нужен больший диапазон.) Независимо от выбранного диапазона, доля генерируемых значений, которые отклоняются, всегда будет меньше 0,5, поэтому ожидаемое количество отклонений всегда будет меньше 1,0, и обычно близко к 0.0; Вам не нужно беспокоиться о том, что это зациклится навсегда.

const randomInteger = (min, max) => {
  const range = max - min;
  const maxGeneratedValue = 0xFFFFFFFF;
  const possibleResultValues = range + 1;
  const possibleGeneratedValues = maxGeneratedValue + 1;
  const remainder = possibleGeneratedValues % possibleResultValues;
  const maxUnbiased = maxGeneratedValue - remainder;

  if (!Number.isInteger(min) || !Number.isInteger(max) ||
       max > Number.MAX_SAFE_INTEGER || min < Number.MIN_SAFE_INTEGER) {
    throw new Error('Arguments must be safe integers.');
  } else if (range > maxGeneratedValue) {
    throw new Error('Range of ${range} (from ${min} to ${max}) > ${maxGeneratedValue}.');
  } else if (max < min) {
    throw new Error('max (${max}) must be >= min (${min}).');
  } else if (min === max) {
    return min;
  } 

  let generated;
  do {
    generated = crypto.getRandomValues(new Uint32Array(1))[0];
  } while (generated > maxUnbiased);

  return min + (generated % possibleResultValues);
};

console.log(randomInteger(-8, 8));          // -2
console.log(randomInteger(0, 0));           // 0
console.log(randomInteger(0, 0xFFFFFFFF));  // 944450079
console.log(randomInteger(-1, 0xFFFFFFFF));
// Error: Range of 4294967296 covering -1 to 4294967295 is > 4294967295.
console.log(new Array(12).fill().map(n => randomInteger(8, 12)));
// [11, 8, 8, 11, 10, 8, 8, 12, 12, 12, 9, 9]
+1
10 апр. '16 в 9:26
источник

Я обнаружил отличный новый способ сделать это, используя параметры по умолчанию ES6. Это очень изящно, поскольку допускает либо один аргумент, либо два аргумента. Вот:

function random(n, b = 0) {
    return Math.random() * (b-n) + n;
}
0
17 июл. '19 в 17:00
источник

Чтобы создать случайное число в javascript, мы можем использовать встроенный объект javascript Math. Объект Math содержит функцию Math.random(). Эта функция делает следующее (источник MDN):

Функция Math.random() возвращает псевдослучайное число с плавающей точкой в диапазоне 0–1 (включая 0, но не 1) с приблизительно равномерным распределением по этому диапазону, которое затем можно масштабировать до желаемого диапазона.

Учитывая эту функциональность, мы можем легко масштабировать ее в более сложные сценарии. Например:

function randomNR (x, y){
return Math.round((Math.random() * x + y));
}

// dice >> random number between 1-6
// dice functionality without function >> Math.round((Math.random() * 5 + 1))
console.log(randomNR(5,1));


// coin >> random number between 0-1
// coin functionality without function >> Math.round((Math.random() * 1))
console.log(randomNR(1,0))
0
13 окт. '18 в 7:36
источник
function random(min, max){
    return Math.floor(Math.random() * (max - min + 1)) + min;
}
0
19 авг. '17 в 21:53
источник

Это должно работать:

const getRandomNum = (min, max) => Math.floor(Math.random() * (max - min + 1)) + min
0
16 июл. '19 в 12:47
источник

Это решение отображает случайное число от 0 до 1.

Math.random();

если мы используем это, мы можем получить результат, например 0.6353540565013625

-3
09 авг. '16 в 4:54
источник

Я обнаружил, что решение Francisc выше не включало минимальное или максимальное число в результатах, поэтому я изменил его следующим образом:

function randomInt(min,max)
{
    return Math.floor(Math.random()*(max-(min+1))+(min+1));
}
-5
22 февр. '14 в 10:35
источник

Посмотрите другие вопросы по меткам или Задайте вопрос