erstellen Sie ein Array mit zufälligen Werten in Javascript

Der kürzeste Ansatz (ES6)

// randomly generated N = 40 length array 0 <= A[N] <= 39
Array.from({length: 40}, () => Math.floor(Math.random() * 40));

Genießen!

ES5:

function randomArray(length, max) {
    return Array.apply(null, Array(length)).map(function() {
        return Math.round(Math.random() * max);
    });
}

ES6:

randomArray = (length, max) => [...new Array(length)]
    .map(() => Math.round(Math.random() * max));

Noch kürzerer ES6-Ansatz:

Array(40).fill().map(() => Math.round(Math.random() * 40))

Sie könnten auch eine Funktion mit Argumenten haben:

const randomArray = (length, max) => 
  Array(length).fill().map(() => Math.round(Math.random() * max))

Math.random() liefert eine Zahl zwischen 0 und 1 (exklusiv). Wenn Sie also 0-40 wünschen, können Sie es mit 40 multiplizieren. Das höchste Ergebnis, das Sie je erzielen können, ist das, was Sie mit multiplizieren.

var arr = [];
for (var i=0, t=40; i<t; i++) {
    arr.Push(Math.round(Math.random() * t))
}
document.write(arr);

http://jsfiddle.net/robert/tUW89/

Kürzeste :-)

[...Array(40)].map(e=>~~(Math.random()*40))

.. das Array, das ich bekomme, ist sehr wenig randomisiert. Es erzeugt viele Blöcke von aufeinanderfolgenden Zahlen ...

Sequenzen von zufälligen Gegenständen enthalten oft Blöcke von aufeinanderfolgenden Zahlen, siehe Gambler's Fallacy . Zum Beispiel:

Wir haben gerade vier Köpfe hintereinander geworfen. Da die Wahrscheinlichkeit von Ein Durchlauf von fünf aufeinanderfolgenden Köpfen ist nur 1⁄32 .. eine Person, die der .__ unterliegt. Der Trugschluss eines Spielers könnte glauben, dass dieser nächste Schlag weniger wahrscheinlich war Köpfe sein als Schwänze sein . http://en.wikipedia.org/wiki/Gamblers_fallacy

Da der Zahlenbereich eingeschränkt ist, würde ich sagen, dass das Array am besten erzeugt wird. Füllen Sie es mit den Zahlen 0 bis 39 (in Reihenfolge) und mischen Sie es anschließend.

Treiben Sie täglich Single-Line-Lösungen.

Die Werte in Arrays sind total zufällig. Wenn Sie also diese Ausschnitte verwenden, werden sie sich unterscheiden.

Ein Array (Länge 10) mit zufälligen Zeichen in Kleinbuchstaben

Array.apply(null, Array(10)).map(function() { return String.fromCharCode(Math.floor(Math.random() * (123 - 97) + 97)); })

['k', 'a', 'x', 'y', 'n', 'w', 'm', 'q', 'b', 'j']

Ein Array (Länge 10) mit Zufallszahlen von 0 bis 99

Array.apply(null, Array(10)).map(function() { return Math.floor(Math.random() * 100 % 100); })

[86, 77, 83, 27, 79, 96, 67, 75, 52, 21]

Ein zufälliges Datenfeld (von vor 10 Jahren bis jetzt) ​​

Array.apply(null, Array(10)).map(function() { return new Date((new Date()).getFullYear() - Math.floor(Math.random() * 10), Math.floor(Math.random() * 12), Math.floor(Math.random() * 29) )})

[2008-08-22T21: 00: 00.000Z, 2007-07-17T21: 00: 00.000Z,
2015-05-05T21: 00: 00.000Z, 2011-06-14T21: 00: 00.000Z,
2009-07-23T21: 00: 00.000Z, 2009-11-13T22: 00: 00.000Z,
2010-05-09T21: 00: 00.000Z, 2008-01-05T22: 00: 00.000Z,
2016-05-06T21: 00: 00.000Z, 2014-08-06T21: 00: 00.000Z]

Ein Array (Länge 10) zufällige Zeichenfolgen

Array.apply(null, Array(10)).map(function() { return Array.apply(null, Array(Math.floor(Math.random() * 10  + 3))).map(function() { return String.fromCharCode(Math.floor(Math.random() * (123 - 97) + 97)); }).join('') });

['cubjjhaph', 'bmwy', 'alhobd', 'ceud', 'tnyullyn', 'vpkdflarhnf', 'hvg', 'arazuln', 'jzz', 'cyx']

Weitere nützliche Dinge finden Sie hier https://github.com/setivolkylany/nodejs-utils/blob/master/utils/faker.js

var myArray = [];
var arrayMax = 40;
var limit = arrayMax + 1;
for (var i = 0; i < arrayMax; i++) {
  myArray.Push(Math.floor(Math.random()*limit));
}

Dies ist der traditionelle Weg, um dies zu tun, aber @Pointy und @Phrogz sollten Sie wählen, wenn Du Duplikate in Deinem Array vermeiden möchtest, ohne teure Berechnungen durchführen zu müssen

let randomNumber = Array.from({length: 6}, () => Math.floor(Math.random() * 39));

das Array wurde auf 6 Werte begrenzt, um die Anzeige zu vereinfachen.

Mit einigen neuen ES6-Funktionen kann dies nun mit folgenden Elementen erreicht werden:

function getRandomInt(min, max) {
    "use strict";
    if (max < min) {
        // Swap min and max
        [min, max] = [min, max];
    }

    // Generate random number n, where min <= n <= max
    let range = max - min + 1;
    return Math.floor(Math.random() * range) + min;
}

let values = Array.from({length: 40}, () => getRandomInt(0, 40));

console.log(values);

Beachten Sie, dass diese Lösung nur in modernen Browsern funktioniert, die diese ES6-Funktionen unterstützen: Pfeilfunktionen und Array.from ().

Ich brauchte etwas anderes als das, was diese Lösungen gaben, insofern, als ich ein Array mit einer Anzahl unterschiedlicher Zufallszahlen erstellen musste, die an einen bestimmten Bereich gebunden waren. Unten ist meine Lösung. 

function getDistinctRandomIntForArray(array, range){
   var n = Math.floor((Math.random() * range));
   if(array.indexOf(n) == -1){        
    return n; 
   } else {
    return getDistinctRandomIntForArray(array, range); 
   }
}

function generateArrayOfRandomInts(count, range) {
   var array = []; 
   for (i=0; i<count; ++i){
    array[i] = getDistinctRandomIntForArray(array, range);
   };
   return array; 
}

Ich hätte es vorgezogen, keine Schleife zu erstellen, die die Möglichkeit hat, mit vielen unnötigen Anrufen zu enden (wenn Ihre Anzahl und Reichweite hoch sind und nahe derselben Nummer liegen), aber dies ist das Beste, was ich mir vorstellen könnte. 

Wenn Sie es mit zufälligen eindeutigen Werten von 0 ... Längenbereich benötigen:

const randomRange = length => {
  const results = []
  const possibleValues = Array.from({ length }, (value, i) => i)

  for (let i = 0; i < length; i += 1) {
    const possibleValuesRange = length - (length - possibleValues.length)
    const randomNumber = Math.floor(Math.random() * possibleValuesRange)
    const normalizedRandomNumber = randomNumber !== possibleValuesRange ? randomNumber : possibleValuesRange

    const [nextNumber] = possibleValues.splice(normalizedRandomNumber, 1)

    results.Push(nextNumber)
  }

  return results
}

randomRange(5) // [3, 0, 1, 4, 2]

von der von @Phrogz vorgeschlagenen Seite

for (var i=0,nums=[];i<49;i++) nums[i]={ n:i, Rand:Math.random() };
nums.sort( function(a,b){ a=a.Rand; b=b.Rand; return a<b?-1:a>b?1:0 } );

function shuffle(maxElements) {
    //create ordered array : 0,1,2,3..maxElements
    for (var temArr = [], i = 0; i < maxElements; i++) {
        temArr[i] = i;
    }

    for (var finalArr = [maxElements], i = 0; i < maxElements; i++) {
        //remove rundom element form the temArr and Push it into finalArrr
        finalArr[i] = temArr.splice(Math.floor(Math.random() * (maxElements - i)), 1)[0];
    }

    return finalArr
}

Ich denke, diese Methode löst das Problem mit den Wahrscheinlichkeiten, die nur durch den Zufallszahlengenerator begrenzt sind.