Existe-t-il un moyen de générer un nombre aléatoire dans une plage spécifiée (par exemple de 1 à 6: 1, 2, 3, 4, 5 ou 6) en JavaScript?

Important

Le code suivant ne fonctionne que si la valeur minimale est 1. Il ne fonctionne pas pour des valeurs minimales autres que1 .

Si vous vouliez obtenir un entier aléatoire entre 1 ( et seulement 1 ) et 6, vous calculeriez:

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

Où:

• 1 est le numéro de départ
• 6 est le nombre de résultats possibles (1 + début (6) - fin (1) )

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

Ce qu'il fait "extra", c'est qu'il permet des intervalles aléatoires qui ne commencent pas par 1. Vous pouvez donc obtenir un nombre aléatoire de 10 à 15 par exemple. Souplesse.

Math.random ()

Renvoie un nombre aléatoire entier compris entre min ( inclus ) et max ( inclus ):

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

Ou tout nombre aléatoire compris entre min ( inclus ) et max ( non inclus ):

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

Exemples utiles (entiers):

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

** Et toujours agréable d'être rappelé (Mozilla):

Math.random () ne fournit pas de nombres aléatoires sécurisés cryptographiquement. Ne les utilisez pas pour tout ce qui concerne la sécurité. Utilisez plutôt l'API Web Crypto, et plus précisément la méthode window.crypto.getRandomValues ​​().

Autres solutions:

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

Essayez en ligne

TL; DR

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

Pour obtenir le nombre aléatoire generateRandomInteger(-20, 20);

EXPLICATION CI-DESSOUS

Nous devons obtenir un entier aléatoire, disons X entre min et max.

Droite?

c'est-à-dire min <= X <= max

Si nous soustrayons min de l'équation, cela équivaut à

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

Maintenant, multiplions cela par un nombre aléatoire r qui est

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

Maintenant, ajoutons de nouveau min à l'équation

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

Maintenant, permet de choisir une fonction qui résulte en r telle qu'elle satisfait notre plage d'équations comme [min, max]. Ceci n'est possible que si 0 <= r <= 1

D'ACCORD. Maintenant, la plage de r ie [0,1] est très similaire au résultat de la fonction Math.random (). N'est-ce pas?

La fonction Math.random () renvoie un nombre pseudo-aléatoire à virgule flottante dans la plage [0, 1); c'est-à-dire de 0 (inclus) à 1 non compris (exclusif)

Par exemple,

Cas r = 0

min+ 0 * ( max- min) = min

Cas r = 1

min+ 1 * ( max- min) = max

Cas aléatoire utilisant Math.random 0 <= r <1

min+ r * ( max- min) = X , où X a une plage de min <= X < max

Le résultat ci-dessus X est un numérique aléatoire. Cependant, en raison de Math.random (), notre limite gauche est inclusive et la limite droite est exclusive. Pour inclure notre limite droite, nous augmentons la limite droite de 1 et fixons le résultat.

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

Pour obtenir le nombre aléatoire

generateRandomInteger(-20, 20);

Ou, dans 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/

Entier aléatoire : pour obtenir un entier aléatoire entre minet max, utilisez le code suivant

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

Numéro à virgule flottante aléatoire: pour obtenir un nombre à virgule flottante aléatoire entre minet max, utilisez le code suivant

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

Référence: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/random

Les mathématiques ne sont pas mon point fort, mais j'ai travaillé sur un projet où je devais générer beaucoup de nombres aléatoires entre les deux positifs et négatifs.

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

Par exemple

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

Bien sûr, vous pouvez également ajouter une validation pour vous assurer de ne pas le faire avec autre chose que des chiffres. Assurez-vous également que min est toujours inférieur ou égal à max.

J'ai écrit une fonction plus flexible qui peut vous donner un nombre aléatoire mais pas seulement un entier.

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

Version fixe.

Exemple

Renvoyez un nombre aléatoire entre 1 et 10:

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

Le résultat pourrait être: 3

Essayez-vous: ici

-

ou en utilisant lodash / undescore:

_.random(min, max)

Documents: - lodash - undescore

Malgré de nombreuses réponses et presque le même résultat. Je voudrais ajouter ma réponse et expliquer son fonctionnement. Parce qu'il est important de comprendre son fonctionnement plutôt que de copier-coller un code de ligne. Générer des nombres aléatoires n'est rien d'autre que de simples calculs.

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

Je cherchais un générateur de nombres aléatoires écrit en TypeScript et je l'ai écrit après avoir lu toutes les réponses, j'espère que cela fonctionnera pour les codeurs TypeScript.

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

Math.random() est rapide et convient à de nombreuses fins, mais ce n'est pas approprié si vous avez besoin de valeurs sécurisées sur le plan cryptographique (ce n'est pas sécurisé), ou si vous avez besoin d'entiers d'une distribution sans biais complètement uniforme (l'approche de multiplication utilisée dans d'autres réponses produit certaines valeurs un peu plus souvent que d'autres).

Dans de tels cas, nous pouvons utiliser crypto.getRandomValues()pour générer des entiers sécurisés et rejeter toutes les valeurs générées que nous ne pouvons pas mapper uniformément dans la plage cible. Ce sera plus lent, mais il ne devrait être significatif que si vous générez un nombre extrêmement élevé de valeurs.

Pour clarifier le problème de distribution biaisée, considérons le cas où nous voulons générer une valeur entre 1 et 5, mais nous avons un générateur de nombres aléatoires qui produit des valeurs entre 1 et 16 (une valeur de 4 bits). Nous voulons avoir le même nombre de valeurs générées correspondant à chaque valeur de sortie, mais 16 ne se divise pas également par 5: il reste un reste de 1. Nous devons donc rejeter 1 des valeurs générées possibles et continuer uniquement lorsque nous obtenons l'une des 15 valeurs inférieures qui peuvent être uniformément mappées dans notre plage cible. Notre comportement pourrait ressembler à ce 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.

Le code suivant utilise une logique similaire, mais génère à la place un entier 32 bits, car il s'agit de la plus grande taille d'entier commun pouvant être représentée par le numbertype standard de JavaScript . (Cela peut être modifié pour utiliser BigInts si vous avez besoin d'une plus grande plage.) Quelle que soit la plage choisie, la fraction des valeurs générées qui sont rejetées sera toujours inférieure à 0,5, donc le nombre attendu de rejets sera toujours inférieur à 1,0 et généralement proche de 0,0; vous n'avez pas à vous en préoccuper en boucle pour toujours.

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]

Ajout floatavec une version de précision fixe basée sur la intversion dans la réponse de @ Francisc:

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

donc:

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

et pour réponse int

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

Nombre entier aléatoire crypto-fort dans la plage [a, b] (hypothèse: a <b)

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

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

Cela devrait fonctionner:

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

J'ai découvert une excellente nouvelle façon de le faire en utilisant les paramètres par défaut d'ES6. Il est très astucieux car il autorise soit un argument, soit deux arguments. C'est ici:

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

C'est environ neuf ans de retard, mais randojs.com en fait un simple doublure:

rando(1, 6)

Vous avez juste besoin d'ajouter cela en tête de votre document html, et vous pouvez faire à peu près tout ce que vous voulez avec aléatoire. Valeurs aléatoires des tableaux, éléments jquery aléatoires, propriétés aléatoires des objets, et même empêchant les répétitions si nécessaire.

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

Cela fonctionne pour moi et produit des valeurs comme la fonction de bibliothèque standard random.randint de Python :

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

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

Essayez d'utiliser:

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

renvoyer 1-6 comme un dé en gros,

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