Esiste un modo per generare un numero casuale in un intervallo specificato (ad es. Da 1 a 6: 1, 2, 3, 4, 5 o 6) in JavaScript?

Importante

Il codice seguente funziona solo se il valore minimo è 1. Non funziona con valori minimi diversi da 1.

Se desideri ottenere un numero intero casuale compreso tra 1 ( e solo 1 ) e 6, dovresti calcolare:

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

Dove:

• 1 è il numero iniziale
• 6 è il numero di risultati possibili (1 + inizio (6) - fine (1) )

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

Ciò che fa "extra" è che consente intervalli casuali che non iniziano con 1. Quindi, ad esempio, puoi ottenere un numero casuale da 10 a 15. Flessibilità.

Math.random ()

Restituisce un numero casuale intero compreso tra min ( incluso ) e max ( incluso ):

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

O qualsiasi numero casuale tra min ( incluso ) e max ( non incluso ):

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

Esempi utili (numeri interi):

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

** E sempre bello da ricordare (Mozilla):

Math.random () non fornisce numeri casuali crittograficamente sicuri. Non utilizzarli per nulla relativi alla sicurezza. Utilizzare invece l'API Web Crypto e, più precisamente, il metodo window.crypto.getRandomValues ​​().

Altre soluzioni:

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

Prova online

TL; DR

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

Per ottenere il numero casuale generateRandomInteger(-20, 20);

SPIEGAZIONE QUI SOTTO

Dobbiamo ottenere un numero intero casuale, diciamo X tra min e max.

Giusto?

cioè min <= X <= max

Se sottraggiamo min dall'equazione, questo equivale a

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

Ora, moltiplica questo per un numero casuale r che è

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

Ora, consente di aggiungere di nuovo min all'equazione

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

Ora, scegliamo una funzione che risulti in r tale da soddisfare la nostra gamma di equazioni come [min, max]. Questo è possibile solo se 0 <= r <= 1

OK. Ora, l'intervallo di r ie [0,1] è molto simile al risultato della funzione Math.random (). No?

La funzione Math.random () restituisce un numero pseudo-casuale in virgola mobile nell'intervallo [0, 1); cioè da 0 (incluso) fino a ma non incluso 1 (esclusivo)

Per esempio,

Caso r = 0

min+ 0 * ( max- min) = min

Caso r = 1

min+ 1 * ( max- min) = max

Caso casuale utilizzando Math.random 0 <= r <1

min+ r * ( max- min) = X , dove X ha un intervallo di min <= X < max

Il risultato sopra X è un numero casuale. Tuttavia, a causa di Math.random () il nostro limite sinistro è inclusivo e il limite destro è esclusivo. Per includere il limite destro, aumentiamo il limite destro di 1 e calcoliamo il risultato.

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

Per ottenere il numero casuale

generateRandomInteger(-20, 20);

Oppure, in Underscore

_.random(min, max)

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

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

Intero casuale : per ottenere un numero intero casuale compreso tra mine max, utilizzare il seguente codice

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

Numero in virgola mobile casuale: per ottenere un numero in virgola mobile casuale tra mine max, utilizzare il seguente codice

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

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

La matematica non è il mio punto di forza, ma ho lavorato a un progetto in cui avevo bisogno di generare molti numeri casuali tra positivo e negativo.

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

Per esempio

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

Naturalmente, puoi anche aggiungere un po 'di validazione per assicurarti di non farlo con nient'altro che numeri. Assicurarsi inoltre che min sia sempre inferiore o uguale a max.

Ho scritto una funzione più flessibile che può darti un numero casuale ma non solo un numero intero.

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

Versione fissa.

Esempio

Restituisce un numero casuale compreso tra 1 e 10:

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

Il risultato potrebbe essere: 3

Mettiti alla prova: qui

-

o usando lodash / undescore:

_.random(min, max)

Documenti: - lodash - undescore

Nonostante molte risposte e quasi lo stesso risultato. Vorrei aggiungere la mia risposta e spiegarne il funzionamento. Perché è importante capirne il funzionamento piuttosto che copiare incollando un codice di riga. Generare numeri casuali non è altro che semplici matematiche.

CODICE:

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

Stavo cercando un generatore di numeri casuali scritto in TypeScript e ho scritto questo dopo aver letto tutte le risposte, spero che funzioni per i programmatori TypeScript.

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

Math.random() è veloce e adatto a molti scopi, ma non è appropriato se hai bisogno di valori crittograficamente sicuri (non è sicuro) o se hai bisogno di numeri interi da una distribuzione imparziale completamente uniforme (l'approccio di moltiplicazione utilizzato nelle altre risposte produce alcuni valori leggermente più spesso di altri).

In questi casi, possiamo usare crypto.getRandomValues()per generare numeri interi sicuri e rifiutare qualsiasi valore generato che non possiamo mappare uniformemente nell'intervallo target. Questo sarà più lento, ma non dovrebbe essere significativo se non stai generando un numero estremamente elevato di valori.

Per chiarire la preoccupazione di distribuzione distorta, considera il caso in cui vogliamo generare un valore compreso tra 1 e 5, ma abbiamo un generatore di numeri casuali che produce valori compresi tra 1 e 16 (un valore a 4 bit). Vogliamo avere lo stesso numero di valori generati associati a ciascun valore di output, ma 16 non si divide uniformemente per 5: lascia un resto di 1. Quindi dobbiamo rifiutare 1 dei possibili valori generati e continuare solo quando otteniamo uno dei 15 valori minori che possono essere uniformemente mappati nel nostro intervallo target. Il nostro comportamento potrebbe apparire come questo pseudocodice:

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.

Il codice seguente utilizza una logica simile, ma genera invece un numero intero a 32 bit, poiché si tratta della dimensione intera comune più grande che può essere rappresentata dal numbertipo standard di JavaScript . (Questo potrebbe essere modificato per usare BigInts se hai bisogno di un intervallo più ampio.) Indipendentemente dall'intervallo scelto, la frazione dei valori generati che vengono rifiutati sarà sempre inferiore a 0,5, quindi il numero atteso di rifiuti sarà sempre inferiore a 1,0 e di solito vicino a 0,0; non devi preoccuparti che rimanga in loop per sempre.

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]

Aggiunta floatcon versione a precisione fissa basata sulla intversione nella risposta di @ Francisc:

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

così:

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

e per la risposta int

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

Numero intero casuale cripto-forte nell'intervallo [a, b] (presupposto: a <b)

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

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

Questo dovrebbe funzionare:

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

Ho scoperto un nuovo fantastico modo per farlo usando i parametri predefiniti ES6. È molto intelligente poiché consente uno o due argomenti. Ecco qui:

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

Sono in ritardo di circa nove anni, ma randojs.com lo rende un semplice esempio:

rando(1, 6)

Devi solo aggiungere questo alla testa del tuo documento html e puoi fare praticamente tutto ciò che vuoi con casualità facilmente. Valori casuali da matrici, elementi jquery casuali, proprietà casuali dagli oggetti e persino prevenzione delle ripetizioni, se necessario.

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

Questo funziona per me e produce valori come la funzione di libreria standard random.randint di Python :

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

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

Prova a usare:

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

per restituire 1-6 come un dado fondamentalmente,

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