function randomIntFromInterval(min, max) { // min and max included 
  return Math.floor(Math.random() * (max - min + 1) + min)
}
const rndInt = randomIntFromInterval(1, 6)
console.log(rndInt)

Antwoord 3, autoriteit 17%

Math.random()

Retourneert een geheel willekeurig getaltussen min (inbegrepen) en max (inbegrepen):

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

Of een willekeurig getaltussen min (inbegrepen) en max (niet inbegrepen):

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

Handige voorbeelden (gehele getallen):

// 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;

** En altijd leuk om eraan herinnerd te worden (Mozilla):

Math.random() biedt geen cryptografisch veilige willekeurige
nummers. Gebruik ze niet voor alles wat met beveiliging te maken heeft. Gebruik het web
Crypto API in plaats daarvan, en meer precies de
window.crypto.getRandomValues() methode.

Antwoord 4, autoriteit 4%

Andere oplossingen:

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

Online proberen

Antwoord 5, autoriteit 3%

TL;DR

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

Om het willekeurige nummer te krijgen
generateRandomInteger(-20, 20);

UITLEG HIERONDER

We moeten een willekeurig geheel getal krijgen, zeg Xtussen min en max.

Toch?

d.w.z
min <= X <= max

Als we min van de vergelijking aftrekken, is dit gelijk aan

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

Laten we dit nu vermenigvuldigen met een willekeurig getal r
dat is

0 <= (X – min) * r <= (max – min) * r

Laten we nu minaan de vergelijking toevoegen

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

Laten we nu een functie kiezen die resulteert in rzodat deze voldoet aan ons vergelijkingsbereik als [min,max]. Dit is alleen mogelijk als 0<= r <=1

Oké. Nu lijkt het bereik van rd.w.z. [0,1] erg op het resultaat van de functie Math.random() . Is het niet?

De functie Math.random() retourneert een drijvende-komma, pseudo-willekeurig
getal in het bereik [0, 1); dat wil zeggen, van 0 (inclusief) tot maar niet
inclusief 1 (exclusief)

Bijvoorbeeld

Zaak r = 0

min+ 0 * (max–min) = min

Zaak r = 1

min+ 1 * (max–min) = max

Willekeurig hoofdlettergebruik met Math.random 0 <= r < 1

min+ r * (max–min) = X, waarbij Xheeft een bereik van min<= X< max

Het bovenstaande resultaat Xis een willekeurig getal. Vanwege Math.random() is onze linkergrens echter inclusief en is de rechtergrens exclusief. Om onze rechtergrens op te nemen, verhogen we de rechtergrens met 1 en verlagen we het resultaat.

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

Om het willekeurige getal te krijgen

generateRandomInteger(-20, 20);

Antwoord 6

Of, in Onderstrepingsteken

_.random(min, max)

Antwoord 7

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

Antwoord 8

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

Random Integer: om een ​​willekeurig geheel getal tussen minen maxte krijgen, gebruikt u de volgende code

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

Willekeurig getal met drijvende komma: gebruik de volgende code om een ​​willekeurig getal met drijvende komma tussen minen maxte krijgen

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

Referentie: https://developer. mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/random

Antwoord 9

Wiskunde is niet mijn sterkste punt, maar ik heb aan een project gewerkt waarbij ik veel willekeurige getallen moest genereren tussen zowel positief als negatief.

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

Bijvoorbeeld

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

Natuurlijk kun je ook wat validatie toevoegen om ervoor te zorgen dat je dit niet met iets anders dan cijfers doet. Zorg er ook voor dat min altijd kleiner is dan of gelijk is aan max.

Antwoord 10

Ik heb een flexibelere functie geschreven die je een willekeurig getal kan geven, maar niet alleen een geheel getal.

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

Vaste versie.

Antwoord 11

Voorbeeld

Retourneer een willekeurig getal tussen 1 en 10:

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

Het resultaat kan zijn:
3

Probeer het zelf: hier

—

of met behulp van lodash / undescore:

_.random(min, max)

Documenten:
– lodash
– ongedaan maken

Antwoord 12

ES6 / Arrow-functies versie gebaseerd op Francis’ code (d.w.z. het beste antwoord):

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

Antwoord 13

Ik was op zoek naar een generator voor willekeurige getallen geschreven in TypeScript en ik heb dit geschreven na het lezen van alle antwoorden, in de hoop dat het zou werken voor TypeScript-codeerders.

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

Antwoord 14

Ondanks veel antwoorden en bijna hetzelfde resultaat. Ik wil graag mijn antwoord toevoegen en uitleggen hoe het werkt. Omdat het belangrijk is om de werking ervan te begrijpen in plaats van één regel code te kopiëren en plakken. Het genereren van willekeurige getallen is niets anders dan eenvoudige wiskunde.

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

Antwoord 15

Math.random()is snel en geschikt voor vele doeleinden, maar het is niet geschikt als u cryptografisch beveiligde waarden nodig hebt (het is niet veilig), of als u gehele getallen nodig heeft van een volledig uniforme, onbevooroordeelde verdeling (de benadering van vermenigvuldiging die in andere antwoorden wordt gebruikt, levert bepaalde waarden iets vaker op dan andere).

In dergelijke gevallen kunnen we crypto.getRandomValues()gebruiken om veilige gehele getallen te genereren en alle gegenereerde waarden die we niet uniform in het doelbereik kunnen toewijzen, afwijzen. Dit zal langzamer zijn, maar het zou niet significant moeten zijn, tenzij u extreem grote aantallen waarden genereert.

Om het probleem van bevooroordeelde distributie te verduidelijken, overweeg het geval waarin we een waarde tussen 1 en 5 willen genereren, maar we hebben een generator voor willekeurige getallen die waarden tussen 1 en 16 produceert (een 4-bits waarde). We willen dat hetzelfde aantal gegenereerde waarden wordt toegewezen aan elke uitvoerwaarde, maar 16 is niet gelijkelijk gedeeld door 5: er blijft een rest over van 1. We moeten dus 1 van de mogelijke gegenereerde waarden verwerpen en alleen doorgaan als we een van de 15 kleinere waarden die uniform kunnen worden toegewezen aan ons doelbereik. Ons gedrag zou eruit kunnen zien als deze pseudocode:

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.

De volgende code gebruikt vergelijkbare logica, maar genereert in plaats daarvan een 32-bits geheel getal, omdat dat de grootste algemene gehele grootte is die kan worden weergegeven door het standaard number-type van JavaScript. (Dit kan worden gewijzigd om BigInt-en te gebruiken als u een groter bereik nodig hebt.) Ongeacht het gekozen bereik, zal het percentage gegenereerde waarden dat wordt afgewezen altijd kleiner zijn dan 0,5, dus het verwachte aantal afwijzingen zullen altijd kleiner zijn dan 1,0 en meestal dicht bij 0,0; je hoeft je geen zorgen te maken dat het voor altijd in een lus blijft.

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]

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

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

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

randomFloatFromInterval(1,3,0) // => 1, 2, 3

function randomNumber(min, max) {
  if (min > max) {
    let temp = max;
    max = min;
    min = temp;
  }
  if (min <= 0) {
    return Math.floor(Math.random() * (max + Math.abs(min) + 1)) + min;
  } else {
    return Math.floor(Math.random() * (max - min + 1)) + min;
  }
}

randomNumber(-2, 3); // can be -2, -1, 0, 1, 2 and 3
randomNumber(-5, -2); // can be -5, -4, -3 and -2
randomNumber(0, 4); // can be 0, 1, 2, 3 and 4
randomNumber(4, 0); // can be 0, 1, 2, 3 and 4

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

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

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

rando(1, 6)

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

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

Math.ceil(Math.random() * 6)

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

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

function randint(min, max) {
   return Math.round((Math.random() * Math.abs(max - min)) + min);
}
console.log("Random integer: " + randint(-5, 5));

var min_num = 900;
var max_num = 1000;
while(true){
    let num_random = Math.random()* max_num;
    console.log('input : '+num_random);
    if(num_random >= min_num){
        console.log(Math.floor(num_random));
       break; 
    } else {
        console.log(':::'+Math.floor(num_random));
    }
}

Math.floor( Math.random() * MAX_NUMBER ) + MIN_NUMBER

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