특정 범위의 JavaScript에서 임의의 정수를 생성합니까?

질문자 :zacharyliu

JavaScript에서 지정된 두 변수 사이에 임의의 정수를 어떻게 생성할 수 있습니까? 예를 들어 x = 4 및 y = 8 4, 5, 6, 7, 8 중 하나를 출력합니까?

Mozilla 개발자 네트워크 페이지에는 다음과 같은 몇 가지 예가 있습니다.

 /** * Returns a random number between min (inclusive) and max (exclusive) */ function getRandomArbitrary(min, max) { return Math.random() * (max - min) + min; } /** * Returns a random integer between min (inclusive) and max (inclusive). * The value is no lower than min (or the next integer greater than min * if min isn't an integer) and no greater than max (or the next integer * lower than max if max isn't an integer). * Using Math.round() will give you a non-uniform distribution! */ function getRandomInt(min, max) { min = Math.ceil(min); max = Math.floor(max); return Math.floor(Math.random() * (max - min + 1)) + min; }

---

여기에 논리가 있습니다. 세 가지의 간단한 규칙입니다.

Math.random() 은 0(포함)과 1(제외) 사이 Number 를 반환합니다. 따라서 다음과 같은 간격이 있습니다.

 [0 .................................... 1)

min (포함)과 max (배타) 사이의 숫자를 원합니다.

 [0 .................................... 1) [min .................................. max)

Math.random 을 사용하여 [최소, 최대) 간격으로 해당 항목을 얻을 수 있습니다. 그러나 먼저 두 번째 간격에서 min 을 빼서 문제를 약간 분해해야 합니다.

 [0 .................................... 1) [min - min ............................ max - min)

이것은 다음을 제공합니다.

 [0 .................................... 1) [0 .................................... max - min)

Math.random 적용한 다음 해당 상대를 계산할 수 있습니다. 난수를 선택합시다.

 Math.random() | [0 .................................... 1) [0 .................................... max - min) | x (what we need)

x 를 찾기 위해 다음을 수행합니다.

 x = Math.random() * (max - min);

[min, max) 간격으로 숫자를 얻을 수 있도록 min 다시 추가하는 것을 잊지 마십시오.

 x = Math.random() * (max - min) + min;

그것이 MDN의 첫 번째 기능이었습니다. min 과 max 사이의 정수를 반환하며 둘 다 포함합니다.

이제 정수를 얻으려면 round , ceil 또는 floor 사용할 수 있습니다.

Math.round(Math.random() * (max - min)) + min 사용할 수 있지만 이는 고르지 않은 분포를 제공합니다. min 과 max 둘 다 굴릴 확률이 약 절반에 불과합니다.

 min...min+0.5...min+1...min+1.5 ... max-0.5....max └───┬───┘└────────┬───────┘└───── ... ─────┘└───┬──┘ ← Math.round() min min+1 max

max min 보다 롤링할 기회가 훨씬 적습니다.

Math.floor(Math.random() * (max - min +1)) + min 을 사용하면 완벽하게 균일한 분포를 얻을 수 있습니다.

 min.... min+1... min+2 ... max-1... max.... max+1 (is excluded from interval) | | | | | | └───┬───┘└───┬───┘└─── ... ┘└───┬───┘└───┬───┘ ← Math.floor() min min+1 max-1 max

max 이제 롤링할 기회가 약간 줄어들었기 때문에 해당 방정식에서 ceil() 및 -1 을 사용할 수 없지만 (원치 않는) min-1 결과도 롤링할 수 있습니다.

Ionuț G. Stan

var randomnumber = Math.floor(Math.random() * (maximum - minimum + 1)) + minimum;

Darin Dimitrov

Math.random()

min( included )과 max( included ) 사이의 정수 난수를 반환합니다.

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

또는 min( 포함됨 )과 max( 포함되지 않음 ) 사이의 임의의 숫자 :

 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() 메소드를 사용하십시오.

Lior Elrom

function getRandomizer(bottom, top) { return function() { return Math.floor( Math.random() * ( 1 + top - bottom ) ) + bottom; } }

용법:

 var rollDie = getRandomizer( 1, 6 ); var results = "" for ( var i = 0; i<1000; i++ ) { results += rollDie() + " "; //make a string filled with 1000 random numbers in the range 1-6. }

고장:

bottom 과 top 값 사이의 임의의 정수를 반환하는 함수(함수 프로그래밍에서 차용)를 반환하고 있습니다. 반환될 수 있는 숫자의 범위에 하단과 상단을 모두 포함하기를 원하기 때문에 '포함'이라고 합니다. 이런 식으로 getRandomizer( 1, 6 ) 는 1, 2, 3, 4, 5 또는 6을 반환합니다.

(아래가 낮은 숫자, 위쪽이 큰 숫자)

 Math.random() * ( 1 + top - bottom )

Math.random() 은 0과 1 사이의 임의의 double을 반환하고, 여기에 1과 top 과 bottom 0 과 1+ba 사이 어딘가에서 double을 얻을 수 있습니다.

 Math.floor( Math.random() * ( 1 + top - bottom ) )

Math.floor 는 숫자를 가장 가까운 정수로 내림합니다. 0 과 top-bottom 사이의 모든 정수가 있습니다. 1은 혼란스러워 보이지만 항상 내림하므로 거기에 있어야 합니다. 따라서 1이 없으면 맨 위 숫자에 실제로 도달할 수 없습니다. 우리가 생성하는 임의의 십진수는 0 에서 (1+top-bottom) 0 에서 top-bottom 범위의 int를 얻을 수 있습니다.

 Math.floor( Math.random() * ( 1 + top - bottom ) ) + bottom

이전 예제의 코드는 0 및 top-bottom 범위의 정수를 제공하므로 이제 bottom bottom 및 top 범위의 정수를 얻기만 하면 됩니다. :NS

---

참고: 정수가 아닌 값이나 더 큰 수를 먼저 전달하면 바람직하지 않은 동작이 발생하지만 누군가가 요청하지 않는 한 원래 질문의 의도와 다소 거리가 있는 인수 검사 코드를 탐구하지 않을 것입니다. .

Gordon Gustafson

1에서 10 사이의 난수를 반환합니다.

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

1에서 100 사이의 난수를 반환합니다.

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

Prasobh.Kollattu

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

Underscore.js 를 사용하는 경우 대안을 사용할 수 있습니다.

 _.random(min, max)

Codler

이 모든 솔루션은 너무 많은 화력을 사용하므로 하나의 함수만 호출하면 됩니다. Math.random();

Math.random() * max | 0;

이것은 0(포함)과 최대(비포함) 사이의 임의의 int를 반환합니다.

Shams Ansari

0과 최대 사이의 변수가 필요한 경우 다음을 사용할 수 있습니다.

 Math.floor(Math.random() * max);

Stanislav Vincent

0 및 1 의 완벽하게 합리적인 매개 변수를 설명하지 않습니다. ceil 또는 floor 대신 round 를 사용해야 합니다.

 function randomNumber(minimum, maximum){ return Math.round( Math.random() * (maximum - minimum) + minimum); } console.log(randomNumber(0,1)); # 0 1 1 0 1 0 console.log(randomNumber(5,6)); # 5 6 6 5 5 6 console.log(randomNumber(3,-1)); # 1 3 1 -1 -1 -1

Starkers

이 함수를 사용하여 주어진 범위 사이의 난수를 가져옵니다.

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

Community Wiki

다음은 javascript에서 Random 클래스의 MS DotNet 구현입니다.

 var Random = (function () { function Random(Seed) { if (!Seed) { Seed = this.milliseconds(); } this.SeedArray = []; for (var i = 0; i < 56; i++) this.SeedArray.push(0); var num = (Seed == -2147483648) ? 2147483647 : Math.abs(Seed); var num2 = 161803398 - num; this.SeedArray[55] = num2; var num3 = 1; for (var i_1 = 1; i_1 < 55; i_1++) { var num4 = 21 * i_1 % 55; this.SeedArray[num4] = num3; num3 = num2 - num3; if (num3 < 0) { num3 += 2147483647; } num2 = this.SeedArray[num4]; } for (var j = 1; j < 5; j++) { for (var k = 1; k < 56; k++) { this.SeedArray[k] -= this.SeedArray[1 + (k + 30) % 55]; if (this.SeedArray[k] < 0) { this.SeedArray[k] += 2147483647; } } } this.inext = 0; this.inextp = 21; Seed = 1; } Random.prototype.milliseconds = function () { var str = new Date().valueOf().toString(); return parseInt(str.substr(str.length - 6)); }; Random.prototype.InternalSample = function () { var num = this.inext; var num2 = this.inextp; if (++num >= 56) { num = 1; } if (++num2 >= 56) { num2 = 1; } var num3 = this.SeedArray[num] - this.SeedArray[num2]; if (num3 == 2147483647) { num3--; } if (num3 < 0) { num3 += 2147483647; } this.SeedArray[num] = num3; this.inext = num; this.inextp = num2; return num3; }; Random.prototype.Sample = function () { return this.InternalSample() * 4.6566128752457969E-10; }; Random.prototype.GetSampleForLargeRange = function () { var num = this.InternalSample(); var flag = this.InternalSample() % 2 == 0; if (flag) { num = -num; } var num2 = num; num2 += 2147483646.0; return num2 / 4294967293.0; }; Random.prototype.Next = function (minValue, maxValue) { if (!minValue && !maxValue) return this.InternalSample(); var num = maxValue - minValue; if (num <= 2147483647) { return parseInt((this.Sample() * num + minValue).toFixed(0)); } return this.GetSampleForLargeRange() * num + minValue; }; Random.prototype.NextDouble = function () { return this.Sample(); }; Random.prototype.NextBytes = function (buffer) { for (var i = 0; i < buffer.length; i++) { buffer[i] = this.InternalSample() % 256; } }; return Random; }());

사용하다:

 var r = new Random(); var nextInt = r.Next(1, 100); //returns an integer between range var nextDbl = r.NextDouble(); //returns a random decimal

Ariful Islam

크립토 스트롱

ragne [x,y]에서 강력한 암호화 난수를 얻으려면 다음을 시도하십시오.

 let cs= (x,y)=>x+(y-x+1)*crypto.getRandomValues(new Uint32Array(1))[0]/2**32|0 console.log(cs(4,8))

Kamil Kiełczewski

컴퓨터 프로그램을 사용하여 난수를 생성한 후 선택한 숫자가 초기 숫자의 일부 또는 전체인 경우 여전히 난수로 간주됩니다. 그러나 그것이 변경되면 수학자들은 그것을 난수로 받아들이지 않고 편향된 숫자라고 부를 수 있습니다. 그러나 간단한 작업을 위한 프로그램을 개발 중이라면 이것은 고려하지 않을 것입니다. 그러나 복권이나 도박 게임과 같은 귀중한 항목에 대해 난수를 생성하는 프로그램을 개발하는 경우 위의 경우를 고려하지 않으면 프로그램이 경영진에 의해 거부됩니다.

그런 분들을 위해 제 제안은 다음과 같습니다.

사용하여 난수 생성 Math.random() . (이 말 n )

 Now for [0,10) ==> n*10 (ie one digit) and for[10,100) ==> n*100 (ie two digits) and so on. Here squire bracket indicates that boundary is inclusive and round bracket indicates boundary is exclusive. Then remove the rest after the decimal point. (ie get floor) - using Math.floor(), this can be done.

난수표를 읽어서 난수를 고르는 방법을 안다면 위의 과정(1, 10, 100 등을 곱하는 것)이 처음에 언급한 것을 위반하지 않는다는 것을 알 것입니다.( 변경만 하기 때문에 소수점 자리)

다음 예를 연구하고 필요에 맞게 개발하십시오.

샘플 [0,9]가 필요한 경우 n*10의 바닥이 답이 되고 [0,99]가 필요한 경우 n*100의 바닥이 답이 되는 식입니다.

이제 귀하의 역할을 시작하십시오.

특정 범위의 숫자를 물어보셨습니다. (이 경우 당신은 그 범위 사이에서 편향됩니다. - 주사위를 굴려 [1,6]에서 숫자를 취함으로써, 당신은 [1,6]으로 편향되지만 여전히 주사위가 편향되지 않은 경우에만 랜덤입니다 .)

따라서 범위를 고려하십시오 ==> [78, 247] 범위의 요소 수 = 247 - 78 + 1 = 170; (두 경계가 모두 포함되기 때문입니다.

 /*Mthod 1:*/ var i = 78, j = 247, k = 170, a = [], b = [], c, d, e, f, l = 0; for(; i <= j; i++){ a.push(i); } while(l < 170){ c = Math.random()*100; c = Math.floor(c); d = Math.random()*100; d = Math.floor(d); b.push(a[c]); e = c + d; if((b.length != k) && (e < k)){ b.push(a[e]); } l = b.length; } console.log('Method 1:'); console.log(b); /*Method 2:*/ var a, b, c, d = [], l = 0; while(l < 170){ a = Math.random()*100; a = Math.floor(a); b = Math.random()*100; b = Math.floor(b); c = a + b; if(c <= 247 || c >= 78){ d.push(c); }else{ d.push(a); } l = d.length; } console.log('Method 2:'); console.log(d);

참고: 첫 번째 방법에서는 먼저 필요한 숫자가 포함된 배열을 만든 다음 무작위로 다른 배열에 넣었습니다. 방법 2에서는 무작위로 숫자를 생성하고 필요한 범위에 있는지 확인합니다. 그런 다음 배열에 넣습니다. 여기서 나는 2개의 난수를 생성하고 그 합계를 사용하여 유용한 수를 얻는 실패율을 최소화하여 프로그램의 속도를 최대화하였다. 그러나 생성된 숫자를 추가하는 것도 약간의 편향을 줄 것입니다. 따라서 특정 범위 내에서 난수를 생성하는 첫 번째 방법을 권장합니다.

두 가지 방법 모두 콘솔에 결과가 표시됩니다.(콘솔을 열려면 Chrome에서 f12를 누르세요.)

Janaka R Rajapaksha

범위가 있는 임의의 정수의 경우 다음을 시도하십시오.

 function random(minimum, maximum) { var bool = true; while (bool) { var number = (Math.floor(Math.random() * maximum + 1) + minimum); if (number > 20) { bool = true; } else { bool = false; } } return number; }

user1764199

function getRandomInt(lower, upper) { //to create an even sample distribution return Math.floor(lower + (Math.random() * (upper - lower + 1))); //to produce an uneven sample distribution //return Math.round(lower + (Math.random() * (upper - lower))); //to exclude the max value from the possible values //return Math.floor(lower + (Math.random() * (upper - lower))); }

이 기능과 이 기능의 변형을 테스트하려면 아래 HTML/JavaScript를 파일에 저장하고 브라우저에서 엽니다. 이 코드는 백만 개의 함수 호출 분포를 보여주는 그래프를 생성합니다. 코드는 또한 극단적인 경우를 기록하므로 함수가 최대값보다 크거나 최소값보다 작은 값을 생성하면 you.will.know.about.it가 됩니다.

 <html> <head> <script type="text/javascript"> function getRandomInt(lower, upper) { //to create an even sample distribution return Math.floor(lower + (Math.random() * (upper - lower + 1))); //to produce an uneven sample distribution //return Math.round(lower + (Math.random() * (upper - lower))); //to exclude the max value from the possible values //return Math.floor(lower + (Math.random() * (upper - lower))); } var min = -5; var max = 5; var array = new Array(); for(var i = 0; i <= (max - min) + 2; i++) { array.push(0); } for(var i = 0; i < 1000000; i++) { var random = getRandomInt(min, max); array[random - min + 1]++; } var maxSample = 0; for(var i = 0; i < max - min; i++) { maxSample = Math.max(maxSample, array[i]); } //create a bar graph to show the sample distribution var maxHeight = 500; for(var i = 0; i <= (max - min) + 2; i++) { var sampleHeight = (array[i]/maxSample) * maxHeight; document.write('<span style="display:inline-block;color:'+(sampleHeight == 0 ? 'black' : 'white')+';background-color:black;height:'+sampleHeight+'px">&nbsp;[' + (i + min - 1) + ']:&nbsp;'+array[i]+'</span>&nbsp;&nbsp;'); } document.write('<hr/>'); </script> </head> <body> </body> </html>

Chris

1과 6 사이의 난수를 얻으려면 먼저 다음을 수행하십시오.

 0.5 + (Math.random() * ((6 - 1) + 1))

이것은 난수에 6을 곱한 다음 0.5를 더합니다. 다음을 수행하여 숫자를 양의 정수로 반올림합니다.

 Math.round(0.5 + (Math.random() * ((6 - 1) + 1))

이것은 숫자를 가장 가까운 정수로 반올림합니다.

또는 더 이해하기 쉽게 만들려면 다음을 수행하십시오.

 var value = 0.5 + (Math.random() * ((6 - 1) + 1)) var roll = Math.round(value); return roll;

일반적으로 변수를 사용하여 이 작업을 수행하는 코드는 다음과 같습니다.

 var value = (Min - 0.5) + (Math.random() * ((Max - Min) + 1)) var roll = Math.round(value); return roll;

최소값에서 0.5를 빼는 이유는 최소값만 사용하면 최대값보다 하나 더 큰 정수를 얻을 수 있기 때문입니다. 최소값에서 0.5를 빼면 최대값이 반올림되는 것을 근본적으로 방지할 수 있습니다.

도움이 되기를 바랍니다.

Learner.js

다음 코드를 사용하면 주어진 범위에서 반복하지 않고 난수 배열을 생성할 수 있습니다.

 function genRandomNumber(how_many_number,min,max) { // parameters // how_many_number : how many numbers you want to generate. For example it is 5. // min(inclusive) : minimum/low value of a range. it must be any positive integer but less than max. ie 4 // max(inclusive) : maximun value of a range. it must be any positive integer. ie 50 // return type: array var random_number = []; for (var i = 0; i < how_many_number; i++) { var gen_num = parseInt((Math.random() * (max-min+1)) + min); do { var is_exist = random_number.indexOf(gen_num); if (is_exist >= 0) { gen_num = parseInt((Math.random() * (max-min+1)) + min); } else { random_number.push(gen_num); is_exist = -2; } } while (is_exist > -1); } document.getElementById('box').innerHTML = random_number; }

Yusuf

이 질문에 이미 답이 있다는 것을 알고 있지만 내 대답이 누군가에게 도움이 될 수 있습니다.

W3Schools에서 이 간단한 방법을 찾았습니다.

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

이것이 누군가를 도울 수 있기를 바랍니다.

NutCracker

가장 낮은 것과 가장 높은 것 사이의 임의의 정수:

 function randomRange(l,h){ var range = (hl); var random = Math.floor(Math.random()*range); if (random === 0){random+=1;} return l+random; }

가장 우아한 솔루션은 아니지만 빠른 것입니다.

brooklynsweb

다음은 난수를 생성하는 데 사용하는 것입니다.

 function random(high,low) { high++; return Math.floor((Math.random())*(high-low))+low; }

Math.random() 이 0, (포함), 1(배타) 사이의 난수를 생성하기 때문에 우리는 high++ 실행합니다. 제외되는 것은 수학을 실행하기 전에 high를 1만큼 증가시켜야 함을 의미합니다. 그런 다음 높은 값에서 낮은 값을 빼서 생성할 가장 높은 숫자 - 낮음, +낮음, 높음을 정상으로 되돌리고 가장 낮은 숫자를 최소한 낮음으로 만듭니다. 그런 다음 결과 숫자를 반환합니다.

random(7,3) 3,4,5,6, or 7 반환할 수 있습니다.

Travis

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비트 정수를 대신 생성합니다. 이는 JavaScript의 표준 number 유형으로 나타낼 수 있는 가장 큰 공통 정수 크기이기 때문입니다. 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]

Jeremy

다음은 Math.random()을 사용하지 않고 지정된 길이의 난수를 생성할 수 있는 자바스크립트 함수의 예입니다.

 function genRandom(length) { const t1 = new Date().getMilliseconds(); var min = "1",max = "9"; var result; var numLength = length; if (numLength != 0) { for (var i = 1; i < numLength; i++) { min = min.toString() + "0"; max = max.toString() + "9"; } } else { min = 0; max = 0; return; } for (var i = min; i <= max; i++) { //Empty Loop } const t2 = new Date().getMilliseconds(); console.log(t2); result = ((max - min)*t1)/t2; console.log(result); return result; }

Nilesh Pawar

 <!DOCTYPE html> <html> <head> <meta charset="utf-8" /> </head> <body> <script> /* assuming that window.crypto.getRandomValues is available the real range would be fron 0 to 1,998 instead of 0 to 2,000 See javascript documentation for explanation https://developer.mozilla.org/en-US/docs/Web/API/RandomSource/getRandomValues */ var array = new Uint8Array(2); window.crypto.getRandomValues(array); console.log(array[0] + array[1]); </script> </body> </html>

Uint8Array는 최대 999인 최대 3자리 숫자로 채워진 배열을 만듭니다. 이 코드는 매우 짧습니다.

happy

이것은 지수에서 기수 범위 내에서 난수를 얻고 싶었기 때문에 범위의 난수에 대한 나의 견해입니다. 예: 밑수 = 10, 지수 = 2, 이상적으로는 0에서 100 사이의 난수를 제공합니다.

사용에 도움이 된다면 다음과 같습니다.

 // get random number within provided base + exponent // by Goran Biljetina --> 2012 function isEmpty(value){ return (typeof value === "undefined" || value === null); } var numSeq = new Array(); function add(num,seq){ var toAdd = new Object(); toAdd.num = num; toAdd.seq = seq; numSeq[numSeq.length] = toAdd; } function fillNumSeq (num,seq){ var n; for(i=0;i<=seq;i++){ n = Math.pow(num,i); add(n,i); } } function getRandNum(base,exp){ if (isEmpty(base)){ console.log("Specify value for base parameter"); } if (isEmpty(exp)){ console.log("Specify value for exponent parameter"); } fillNumSeq(base,exp); var emax; var eseq; var nseed; var nspan; emax = (numSeq.length); eseq = Math.floor(Math.random()*emax)+1; nseed = numSeq[eseq].num; nspan = Math.floor((Math.random())*(Math.random()*nseed))+1; return Math.floor(Math.random()*nspan)+1; } console.log(getRandNum(10,20),numSeq); //testing: //getRandNum(-10,20); //console.log(getRandNum(-10,20),numSeq); //console.log(numSeq);

Goran B.

예를 들어 설명하고 싶었습니다.

질문 : JavaScript에서 5에서 25 사이의 난수를 생성하는 함수

일반 개요:

(i) 먼저 0부터 시작하여 범위로 변환합니다.

(ii) 그런 다음 원하는 범위로 변환합니다(이렇게 하면 완료하기가 매우 쉽습니다).

따라서 기본적으로 5에서 25 사이의 임의의 정수를 생성하려면 다음을 수행합니다.

a) 첫 번째 단계: (범위로 변환 - 0부터 시작)

"최대"와 "최소" 모두에서 "하한/최소 수"를 뺍니다. 즉

(5-5) - (25-5)

따라서 범위는 다음과 같습니다.

0-20 ...맞나요?

b) 2단계:

이제 범위에 포함된 두 숫자(예: "0과 20 모두")를 원하면 방정식은 다음과 같습니다.

수학 방정식 : Math.floor((Math.random() * 21))

일반 방정식: Math.floor( (Math.random() * (max-min +1) ) )

이제 뺄셈/최소 숫자(즉, 5)를 범위에 추가하면 자동으로 0에서 20까지 => 5에서 25까지의 범위를 얻을 수 있습니다.

다) 3단계

이제 방정식(즉, 5)에서 뺀 차이를 추가하고 전체 방정식에 "Math.floor"를 추가합니다.

수학 방정식 : Math.floor((Math.random() * 21) + 5)

일반 방정식: Math.floor((Math.random() * (max-min +1)) + min )

마지막으로 기능은 다음과 같습니다.

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

NewBieCoder

이것은 모든 기여 중에서 가장 단순화된 것이라고 생각합니다.

 maxNum = 8, minNum = 4 console.log(Math.floor(Math.random() * (maxNum - minNum) + minNum)) console.log(Math.floor(Math.random() * (8 - 4) + 4))

이렇게 하면 4와 8 사이의 난수(4와 8 포함)가 콘솔에 기록됩니다.

Mr Ernest

Ionuț G. Stan 이 훌륭한 답변을 작성했지만 이해하기에는 너무 복잡했습니다. 그래서 저는 Jason Anello의 https://teamtreehouse.com/community/mathfloor-mathrandom-max-min-1-min-explanation 에서 동일한 개념에 대한 더 간단한 설명을 찾았습니다.

참고: Jason의 설명을 읽기 전에 알아야 할 유일한 중요한 사항은 "잘라내기"의 정의입니다. Math.floor() 설명할 때 이 용어를 사용합니다. Oxford 사전은 "truncate"를 다음과 같이 정의합니다.

상단이나 끝을 잘라내어 (무엇을) 줄입니다.

Dani Amsalem

0과 n 사이의 난수를 생성하는 내 방법, 여기서 n <= 10(n 제외):

 Math.floor((Math.random() * 10) % n)

Nitin Jadhav

/* 숫자를 받아들이고 0과 그 숫자 사이의 임의의 정수를 반환하는 randUpTo 라는 함수를 작성하시겠습니까? */

 var randUpTo = function(num) { return Math.floor(Math.random() * (num - 1) + 0); };

/* 범위를 나타내는 두 개의 숫자를 받아들이고 이 두 숫자 사이의 임의의 정수를 반환하는 randBetween 이라는 함수를 작성합니다. */

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

/* 범위를 나타내는 두 개의 숫자를 받아들이고 최소(포함)와 최대(제외) 사이의 난수를 반환하는 randFromTill 이라는 함수를 작성합니다. */

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

/* 범위를 나타내는 두 개의 숫자를 받아들이고 min(포함)과 max(포함) 사이의 임의의 정수를 반환하는 randFromTo 라는 함수를 작성합니다. */

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

Prakhar Mittal

이 코드 조각을 할 수 있습니다.

 let randomNumber = function(first,second){ let number = Math.floor(Math.random()*Math.floor(second)); while(number<first){ number = Math.floor(Math.random()*Math.floor(second)); } return number; }

Achintha Isuru

출처 : http:www.stackoverflow.com/questions/1527803/generating-random-whole-numbers-in-javascript-in-a-specific-range