小开

由于数字的范围受到限制，我认为最好的办法是生成数组，将数字从0填充到39(按顺序) ，然后对其进行洗牌。

小开

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/

小开

我得到的数组是非常小的随机化的，它产生了许多连续的数字块。

随机项的序列通常包含连续的数字块，参见赌徒谬论。例如:

. . 我们已经连续抛出四个头. . 自从可能性一连串的五个头只有132. . 一个人受制于赌徒的谬论可能会认为，这种下一次翻转不太可能是正面而不是反面。 Http://en.wikipedia.org/wiki/gamblers_fallacy

小开

最佳答案

下面是一个对 独一无二数字列表进行洗牌的解决方案(永远不要重复)。

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 不希望这样) ，那么可以到其他地方寻找。 :)

小开

来自@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 } );

小开

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

小开

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

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

我宁愿不要创建一个循环，有可能结束了很多不必要的调用(如果你的计数，范围很高，并接近相同的数字) ，但这是最好的，我可以拿出来。

小开

使用 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 ()。

小开

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
}

我想这种方法将解决的问题与概率，只有随机数生成器的限制。

小开

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

小开

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

数组中的值是完全随机的，因此当您使用这个代码片段时，它会有所不同。

带有小写随机字符的数组(长度为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’]

一个数组(长度为10) ，随机整数从0到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]

数组随机日期(从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.000 Z，2007-07-17T21:00.00.000 Z,
2015-05-05T21:00.00.000 Z，2011-06-14T21:00.00.000 Z,
2009-07-23T21:00.00.000 Z，2009-11-13T22:00.00.000 Z,
2010.05-09T21:00.00.000 Z，2008-01-05T22:00.00.000 Z,
2016-05-06T21:00.00.000 Z，2014-08-06T21:00.00.000 Z ]

数组(长度为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” 宝马, “阿洛伯德” 线索, Tnyullyn, “ vpkdflarhnf” “ hvg” 阿拉祖尔, “ jzz” “ Cyx”]

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

小开

最短途径(ES6) :

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

小开

更简短的 ES6方法:

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

此外，还可以有一个带参数的函数:

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

小开

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

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

小开

如果你需要它的随机唯一值从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]

小开

最短:

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

小开

我很确定这是创建随机数组的最短方法，不需要任何重复

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

小开

参考资料如下:-

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

小开

有点晚了，但我使用 Randojs.com的随机性，因为它使这样的东西超级容易。你可以得到一个从0到39的随机数组，就像这样:

console.log(randoSequence(40));

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

不用担心后勤方面的问题，而且它超级易读，容易理解:)

小开

发电机

一个长度为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)];

小开

下面是一个 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]
}

小开

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

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

小开

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

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

公正。

console.log(vals);

小开

使用 Es6

选择一

new Array(40).fill(0).map(_ => Math.random() * 40 | 0)

创建一个长度为40的空数组，然后用0填充，然后用随机数替换0。 Math.random()生成浮点数，因此使用 < a href = “ https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise _ OR”rel = “ nofollow noReferrer”> Bitwise OR (|)浮点到 int

选择二

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

将 new Array(40).fill(0)替换为 [...Array(40)]-它将克隆长度为40的空(未定义)数组

选择三

使用 Array.from

来自(arrayLike，mapFn)

arrayLike

要转换为数组的类似数组或可迭代的对象。

mapFn (可供选择)

映射函数调用数组中的每个元素。

Array.from({length: 10}, () => Math.floor(Math.random() * 100));

如果要用 UNIQUE 随机数填充

我们将使用 Set来实现这一点，因为我们知道 set 只允许添加唯一的值。

let set = new Set();
while (set.size <= 40) {
set.add((Math.random() * 400) | 0);
}
let randomArray = [...set];

但这里有一点很重要，你需要乘以比数组长度大的数字... 否则生成唯一数字会花费太多时间，它可能会冻结执行很长时间

创建具有随机值的数组

发电机

选择一

选择二

选择三

如果要用 UNIQUE 随机数填充