JavaScriptで指定された範囲（1から6まで：1、2、3、4、5、または6など）の乱数を生成する方法はありますか？

重要

次のコードは、最小値がの場合にのみ機能します1。以外の最小値では機能しません1。

1（および1のみ）と6の間のランダムな整数を取得する場合、次のように計算します。

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

どこ：

• 1は開始番号です
• 6は可能な結果の数です（1 +開始（6） -終了（1））

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

「追加」とは、1で始まらないランダムな間隔を許可することです。したがって、たとえば10から15までの乱数を取得できます。柔軟性。

Math.random（）

min（含まれる）とmax（含まれる）の間の整数の乱数を返します。

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

または、最小（含まれる）と最大（含まれない）の間の任意の乱数：

function randomNumber(min, max) {
  return Math.random() * (max - min) + 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;

**そして、いつでも思い出せます（Mozilla）：

Math.random（）は暗号的に安全な乱数を提供しません。セキュリティに関連するものには使用しないでください。代わりにWeb Crypto APIを使用し、より正確にはwindow.crypto.getRandomValues（）メソッドを使用します。

その他の解決策：

• (Math.random() * 6 | 0) + 1
• ~~(Math.random() * 6) + 1

オンラインで試す

TL; DR

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

乱数を取得するには generateRandomInteger(-20, 20);

以下の説明

ランダムな整数、たとえばXを最小値と最大値の間で取得する必要があります。

正しい？

つまり、 最小<= X <=最大

方程式からminを引くと、これは

0 <=（X-最小）<=（最大-最小）

さて、これに乱数r を掛けてみましょう。

0 <=（X-最小）* r <=（最大-最小）* r

今、方程式に最小値を追加してみましょう

最小<=最小+（X-最小）* r <=最小+（最大-最小）* r

ここで、方程式の範囲[min、max]を満たすようなrをもたらす関数を選択してみましょう。これは、0 <= r <= 1の場合にのみ可能です。

OK。ここで、r ie [0,1] の範囲は、Math.random（）関数の結果と非常によく似ています。だよね？

Math.random（）関数は、範囲[0、1]の浮動小数点の疑似乱数を返します。つまり、0（両端を含む）から1を含まない（両端を含まない）まで

例えば、

ケースr = 0

min+ 0 *（max- min）= 分

ケースr = 1

min+ 1 *（max- min）= 最大

Math.random 0 <= r <1を使用したランダムなケース

min+ r *（max- min）= X、ここでXの範囲はmin <= X <最大

上記の結果Xはランダムな数値です。ただし、Math.random（）により、左の境界は包括的で、右の境界は排他的です。右境界を含めるには、右境界を1増やして結果をフロアします。

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

乱数を取得するには

generateRandomInteger(-20, 20);

または、アンダースコアで

_.random(min, max)

var x = 6; // can be any number
var rand = Math.floor(Math.random()*x) + 1;

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

Random Integer：との間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

数学は私の長所ではありませんが、私は正と負の両方の間で多くの乱数を生成する必要があるプロジェクトに取り組んできました。

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以下であることを確認してください。

私は乱数だけでなく整数を与えることができるより柔軟な関数を書きました。

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

修正バージョン。

例

1から10までの乱数を返します。

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

結果は次のようになります。 3

自分で試してください：ここに

-

またはlodash / undescoreを使用：

_.random(min, max)

ドキュメント：-lodash - undescore

多くの回答とほぼ同じ結果にもかかわらず。私は私の答えを追加して、その働きを説明したいと思います。1行のコードをコピーして貼り付けるのではなく、その動作を理解することが重要だからです。乱数を生成することは単純な数学に他なりません。

コード：

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));
}

TypeScriptで記述された乱数ジェネレータを検索していて、すべての回答を読んだ後、これを記述しました。これがTypeScriptのコーダーで機能することを願っています。

    Rand(min: number, max: number): number {
        return (Math.random() * (max - min + 1) | 0) + min;
    }   

Math.random() は高速で多くの目的に適していますが、暗号で保護された値が必要な場合（安全ではない）、または完全に均一な不偏分布から整数が必要な場合（他の回答で使用されている乗算アプローチは、特定の値をわずかに頻繁に生成します）他より）。

そのような場合、を使用crypto.getRandomValues()して安全な整数を生成し、ターゲット範囲に均一にマッピングできない生成された値を拒否できます。これは遅くなりますが、非常に多数の値を生成する場合を除いて、重要ではありません。

偏った分布の問題を明確にするために、1から5までの値を生成したいが、1から16までの値（4ビット値）を生成する乱数ジェネレータがあるとします。各出力値に同じ数の生成された値をマッピングしたいのですが、16は5で均等に除算されません。残りの1を残します。したがって、可能な生成された値の1つを拒否し、ターゲット範囲に均一にマッピングできる15の小さい値の1つ。私たちの行動は次の疑似コードのようになります。

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、より大きな範囲が必要な場合にs を使用するように変更できます。）選択した範囲に関係なく、拒否される生成値の割合は常に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]

@Francisc の回答のfloatバージョンに基づいて、固定精度バージョンで追加しintます。

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

範囲[a、b]の暗号強度のランダムな整数（仮定：a <b）

let rand= (a,b)=> a+(b-a+1)*crypto.getRandomValues(new Uint32Array(1))[0]/2**32|0

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

これはうまくいくはずです：

const getRandomNum = (min, max) => Math.floor(Math.random() * (max - min + 1)) + min

ES6のデフォルトパラメータを使用してこれを行う優れた新しい方法を発見しました。1つの引数または2つの引数を許可するため、非常に気の利いたものです。ここにあります：

function random(n, b = 0) {
    return Math.random() * (b-n) + n;
}

これは約9年遅れですが、randojs.comはこれをシンプルなワンライナーにします。

rando(1, 6)

これをhtmlドキュメントの先頭に追加するだけで、ランダム性を使用してほとんど何でも簡単に行うことができます。配列からのランダムな値、ランダムなjquery要素、オブジェクトからのランダムなプロパティ、そして必要に応じて繰り返しを防止します。

<script src="https://randojs.com/1.0.0.js"></script>

これは私にとってはうまくいき、Pythonのrandom.randint標準ライブラリ関数のような値を生成します：

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

console.log("Random integer: " + randint(-5, 5));

使ってみてください：

function random(min, max) {
   return Math.round((Math.random() *( Math.abs(max - min))) + min);
}
console.log(random(1, 6));

基本的にサイコロのように1-6を返すには、

return Math.round(Math.random() * 5 + 1);