【问题标题】：Create an array with random values创建具有随机值的数组
【发布时间】：2011-08-15 18:17:36
【问题描述】：

如何创建一个包含 40 个元素、随机值从 0 到 39 的数组？喜欢

[4, 23, 7, 39, 19, 0, 9, 14, ...]

我尝试使用这里的解决方案：

http://freewebdesigntutorials.com/javaScriptTutorials/jsArrayObject/randomizeArrayElements.htm

但我得到的数组很少随机化。它会生成很多连续数字的块......

【问题讨论】：

标签： javascript arrays random

【解决方案1】：

只需两行代码，您就可以生成包含 10 个随机数的数组。

let result = new Array(10)
result = result.fill(0).map(() => Math.random());

只是。

console.log(vals);

【讨论】：

【解决方案2】：

因为*的优先级高于|，所以可以用|0代替Math.floor()来缩短它。

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

【讨论】：

超级简洁，喜欢它

【解决方案3】：

这是一个 ES6 函数，它允许一个最小值和一个最大值，并将生成一个随机顺序的唯一值数组，其中包含从最小值到最大值的所有数字：

const createRandomNumbers = (min, max) => {
  const randomNumbers = new Set()
  const range = max - min + 1

  while (randomNumbers.size < range) {
    randomNumbers.add(~~(Math.random() * range))
  }

  return [...randomNumbers]
}

【讨论】：

很好地使用了 Set() 来保持它的唯一性，但是：(1) 需要在 add() 中添加 "+min" 和 (2) 如果范围很大，循环会迭代越来越多，因为它填充了数组，并且可能会在很长一段时间内出现在最终数字上。

【解决方案4】：

发电机

长度为 40 的 40 个随机可能值 (0 - 39) 没有重复值的数组最好像 @Phrogz 和 @Jared Beck 解释的那样对其进行洗牌。另一种仅用于记录的方法可能是使用生成器。但是与其他提议的解决方案相比，这种方法缺乏性能。

function* generateRandomIterable(n, range) {
  for (let i = 0; i < n; i++) {
    yield ~~(Math.random() * range);
  }
}
const randomArr = [...generateRandomIterable(40,40)];

【讨论】：

【解决方案5】：

聚会有点晚了，但我使用randojs.com 来表示随机性，因为它让这样的事情变得超级简单。你可以像这样得到一个从 0 到 39 的随机打乱的数字数组：

console.log(randoSequence(40));

&lt;script src="https://randojs.com/1.0.0.js"&gt;&lt;/script&gt;

对它的后勤工作没有大惊小怪-加上它超级可读且易于理解:)

【讨论】：

【解决方案6】：

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

将数组限制为 6 个值，以便于查看。

【讨论】：

【解决方案7】：

参考下面：-

let arr = Array.apply(null, {length: 1000}).map(Function.call, Math.random)
/* will create array with 1000 elements */

【讨论】：

【解决方案8】：

我很确定这是创建没有任何重复的随机数组的最短方法

var random_array = new Array(40).fill().map((a, i) => a = i).sort(() => Math.random() - 0.5);

【讨论】：

“相当肯定”，使用keys函数：Array.from(Array(40).keys()).sort(_ => Math.random() - .5)怎么样？您甚至可能会发疯，并使用扩展运算符！但这对我来说太令人兴奋了。

【解决方案9】：

最短的:-)

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

【讨论】：

~~ 是 Math.floor 的简写
这很棒；是否广泛支持 ~~ 速记？（编辑：啊，这只是a bitwise operator，我明白了）
@Curt 仅用于正数
遗憾的是，这不是一个“生硬”的答案。他笑着回答。
@A.J.Uppal OP 要求提供 0-39 的具体示例，所以就这样吧

【解决方案10】：

如果您需要从 0...长度范围内的随机唯一值：

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]

【讨论】：

【解决方案11】：

更短的 ES6 方法：

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

另外，你可以有一个带参数的函数：

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

【讨论】：

.fill() 需要一个值参数
@DamianGreen - .fill() 没有任何参数将用undefined 填充数组，这是.map() 工作唯一需要的东西
@Damjan 有没有办法不重复数字？喜欢这种方法
@Henrique 使用变量？ ?
@Sebj 这可能吗？我的意思是，任何像这样的短方法以及作为长度和最大值的道具对我来说都是完美的:)

【解决方案12】：

最短的方法（ES6）

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

享受吧！

【讨论】：

你是对的。删除了我的评论。实际最短路径的更正版本：[...Array(20)].map(()=>{return Math.floor(Math.random()*30)});
如果我们从答案的方法中删除空格，它比您建议的字符少 4 个字符。当然，如果您对打高尔夫球感兴趣，实际上您忽略了一些简单的字符剪切快捷方式：[...Array(40)].map(_=>Math.ceil(Math.random()*40)); 将比您的少 11 个字符，比原来的少 7 个字符。
（如果我们使用Math.ceil，则不够快，无法更正——需要*39 才能满足OP 的标准，尽管我们将0 作为一个选项。如果我们可以接受1- 40 而不是 0-39，这行得通。否则，减少一个改进字符以返回 Math.floor)

【解决方案13】：

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

【讨论】：

_ 和 i 参数是怎么回事？除非我弄错了，否则在 ES6 中是不必要的。
@AfricanMatt，_ 是当前元素，i 是当前索引。你是对的，在这两种情况下它们都是不必要的。如果您愿意，可以删除它们。
我不知道你认为 ES6 的版本在哪里工作？ Array.from 有效...这是您的代码示例... randomArray = (length: number, max: number) => Array.from({length}) .map(() => Math.floor(Math .random() * max));

【解决方案14】：

每天都有古怪的单线解决方案。

数组中的值是完全随机的，所以当你使用这个 sn-ps 时，它会有所不同。

小写随机字符的数组（长度为 10）

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']

一个从 0 到 99 的随机整数数组（长度为 10）

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

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

一个数组随机日期（从 10 年前到现在）

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]

一个数组（长度为 10）随机字符串

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', “宝马”， 'alhob', 'ceud', 'tnyullyn', 'vpkdlarhnf', 'hvg', '阿拉祖尔'， '爵士'， 'cyx']

您可以在这里找到其他有用的东西https://github.com/setivolkylany/nodejs-utils/blob/master/utils/faker.js

【讨论】：

【解决方案15】：

使用一些新的 ES6 特性，现在可以通过以下方式实现：

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

请注意，此解决方案仅适用于支持以下 ES6 功能的现代浏览器：箭头函数和 Array.from()。

【讨论】：

【解决方案16】：

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
}

我想这种方法可以解决概率问题，仅受随机数生成器的限制。

【讨论】：

【解决方案17】：

.. 我得到的数组很少随机化。它会生成很多连续数字的块...

随机项的序列通常包含连续数字块，请参阅Gambler's Fallacy。例如：

.. 我们刚刚连续抛了四个头.. 因为概率连续五个头的运行只有 1⁄32 .. 一个人受到赌徒谬误可能认为下一次翻转不太可能做头比做尾巴。 http://en.wikipedia.org/wiki/Gamblers_fallacy

【讨论】：

+1 完全正确。人们需要决定是需要真实的（统计上的）随机数，还是“看起来随机”的数字。

【解决方案18】：

Math.random() 将返回一个介于 0 和 1（不包括）之间的数字。所以，如果你想要 0-40，你可以将它乘以 40，最高的结果就是你乘以的结果。

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/

【讨论】：

澄清一下：这是一个字母 L，而不是数字 1，在 "l = 40"、"i

【解决方案19】：

这是一个打乱唯一数字列表的解决方案（永远不会重复）。

for (var a=[],i=0;i<40;++i) a[i]=i;

// http://stackoverflow.com/questions/962802#962890
function shuffle(array) {
  var tmp, current, top = array.length;
  if(top) while(--top) {
    current = Math.floor(Math.random() * (top + 1));
    tmp = array[current];
    array[current] = array[top];
    array[top] = tmp;
  }
  return array;
}

a = shuffle(a);

如果您想允许重复值（这不是 OP 想要的），请查看其他地方。 :)

【讨论】：

如果数字应该是唯一的，这个解决方案很好，但这是一个完全不同的统计/概率问题。我希望这对 OP 来说很清楚，并且与他们的情况无关，但在某些情况下，它会对程序的正确性产生重大影响。（我不是在批评答案，只是为未来的读者竖起大旗。你可能想提一下。）另见：en.wikipedia.org/wiki/Combination（“有”或“无重复”之间的区别
var random_array = new Array(40).fill().map((a, i) => a = i).sort(() => Math.random() - 0.5);我认为这和上面的一样
如何排除它生成数字0？
这是一个 ES6 版本，它允许您在最小值/最大值方面具有一定的灵活性，但仍然可以为您提供一组唯一数字：pastie.org/p/069IAzSzsRhN6JXdAIpPhc

【解决方案20】：

我需要一些与这些解决方案所提供的有点不同的东西，因为我需要创建一个数组，其中包含多个不同的随机数，这些随机数保持在指定的范围内。下面是我的解决方案。

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

我宁愿不创建一个可能导致大量不必要调用的循环（如果您的计数和范围很高并且接近相同的数字）但这是我能来的最好的跟上。

【讨论】：

【解决方案21】：

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

以上是传统的方法，但如果你想避免数组中的重复而不必进行昂贵的计算，我会选择 @Pointy 和 @Phrogz

【讨论】：

【解决方案22】：

来自@Phrogz 建议的页面

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

【讨论】：

【解决方案23】：

由于数字的范围受到限制，我想说最好的办法是生成数组，用数字 0 到 39（按顺序）填充它，然后随机播放。

【讨论】：

这里是a visualization of this technique（尽管该页面使用a terrible shuffle algorithm）。
我不知道他想要之间的每个数字，而是完全随机的？如果他对随机顺序，静态值没问题，那么这将正常工作。
这可能会完成这项工作，但与使用 Math.random() 40 次时的结果略有不同，因为它会强制每个数字出现一次且不重复。