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

, Ou, trait de Soulignement

_.random(min, max)

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

nombre entier aléatoire : pour obtenir un nombre entier aléatoire entre min et 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;
}

nombre aléatoire de virgule flottante : pour obtenir un nombre aléatoire de virgule flottante entre min et 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

mathématiques n'est pas mon point fort, mais j'ai travaillé sur un projet où j'avais besoin de générer beaucoup de nombres aléatoires entre positif et négatif.

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

e. g

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

bien sûr, vous pouvez aussi ajouter une validation pour vous assurer que vous ne faites pas cela avec autre chose que des nombres. 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 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

retourner un nombre aléatoire entre 1 et 10:

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

Le résultat pourrait être: 3

Essayez vous-même: ici

--

ou en utilisant lodash / undescore:

_.random(min, max)

Docs: - lodash - undescore

j'étais en train de chercher le générateur de nombres aléatoires écrit à la machine à écrire et j'ai écrit ceci après avoir lu toutes les réponses, j'espère que cela fonctionnerait pour les codeurs de caractères.

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

en dépit de nombreuses réponses et presque le même résultat. Je voudrais ajouter ma réponse et expliquer son travail. 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 des maths simples.

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

Sens vous avez besoin pour ajouter 1 au nombre maximum, puis soustraire le nombre minimum pour tout ce travail, et j'ai besoin de faire beaucoup d'Entiers aléatoires, cette fonction fonctionne.

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

cela fonctionne avec des nombres négatifs et positifs, et je travaille sur des décimales pour une bibliothèque.

au lieu de Math.random() , vous pouvez utiliser crypto.getRandomValues() pour générer des nombres aléatoires uniformément répartis et protégés par cryptographie. Voici un exemple:

function randInt(min, max) {
  var MAX_UINT32 = 0xFFFFFFFF;
  var range = max - min;

  if (!(range <= MAX_UINT32)) {
    throw new Error(
      "Range of " + range + " covering " + min + " to " + max + " is > " +
      MAX_UINT32 + ".");
  } else if (min === max) {
    return min;
  } else if (!(max > min)) {
    throw new Error("max (" + max + ") must be >= min (" + min + ").");
  }

  // We need to cut off values greater than this to avoid bias in distribution
  // over the range.
  var maxUnbiased = MAX_UINT32 - ((MAX_UINT32 + 1) % (range + 1));

  var rand;
  do {
    rand = crypto.getRandomValues(new Uint32Array(1))[0];
  } while (rand > maxUnbiased);

  var offset = rand % (range + 1);
  return min + offset;
}

console.log(randInt(-8, 8));          // -2
console.log(randInt(0, 0));           // 0
console.log(randInt(0, 0xFFFFFFFF));  // 944450079
console.log(randInt(-1, 0xFFFFFFFF));
// Uncaught Error: Range of 4294967296 covering -1 to 4294967295 is > 4294967295.
console.log(new Array(24).fill().map(n => randInt(8, 12)));
// [11, 8, 8, 11, 10, 8, 8, 12, 12, 12, 9, 9,
//  11, 8, 11, 8, 8, 8, 11, 9, 10, 12, 9, 11]
console.log(randInt(10, 8));
// Uncaught Error: max (8) must be >= min (10).

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

j'ai trouvé la solution de Francisc ci-dessus n'a pas inclus le nombre min ou max dans les résultats, donc je l'ai modifié comme ceci:

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