Javascript每次生成随机唯一数

好的，我需要创建四个1-10之间随机生成的数字，它们不能相同。因此，我的想法是将每个数字添加到数组中，但如何检查该数字是否在数组中，如果在数组中，则重新生成该数字，如果不在数组中，则将新数字添加到数组中

所以基本上会这样

1.创建新编号并添加到阵列 2.创建第二个新编号，检查是否已经存在，如果不存在，则添加到数组中。如果确实存在，请重新创建新号码，再次检查等。。。

---

3.同上，依此类推。

使用数组查看是否已生成数字

var randomArr = [], trackingArr = [],
    targetCount = 4, currentCount = 0,
    min = 1, max = 10,
    rnd;

while (currentCount < targetCount) {
    rnd = Math.floor(Math.random() * (max - min + 1)) + min;
    if (!trackingArr[rnd]) {
        trackingArr[rnd] = rnd;
        randomArr[currentCount] = rnd;
        currentCount += 1;
    }
}

alert(randomArr); // Will contain four unique, random numbers between 1 and 10.

var randomArr=[]，trackingArr=[]，
targetCount=4，currentCount=0，
最小值=1，最大值=10，
rnd；
而（currentCount

工作示例：

var a=[]；
对于（变量i=0；i<5；i++）{
var r=Math.floor（Math.random（）*10）+1；
如果（！（a中的r））
a、 推（r）；
其他的
我--；
}

---

那就够了。但是要小心。如果你使生成的随机数大于五月数（10），你将遇到一个无限循环。

你想要的是所谓的“随机抓取袋”。考虑你有一个“袋子”的数字，每个数字只代表一次在这个袋子里。你可以随机地把数字取出来，取多少就取多少

这里介绍的其他一些解决方案的问题是，它们随机生成数字，并检查是否已经使用过。这将需要越来越长的时间来完成（理论上是无限长的时间），因为您正在等待random（）函数返回一个您还没有的值（它不必这样做，它可以永远给您1-9，但永远不会返回10）

有很多方法可以实现抓取袋式解决方案，每种方法都有不同程度的成本（不过，如果做得正确，永远不会是无限的）

您的问题的最基本解决方案如下：

var grabBag = [1,2,3,4,5,6,7,8,9,10];

// randomize order of elements with a sort function that randomly returns -1/0/1
grabBag.sort(function(xx,yy){ return Math.floor(Math.random() * 3) - 1; })

function getNextRandom(){
    return grabBag.shift();
};

var originalLength = grabBag.length;
for(var i = 0; i < originalLength; i++){
    console.log(getNextRandom());
}

var grabBag=[1,2,3,4,5,6,7,8,9,10]；
//使用随机返回-1/0/1的排序函数随机化元素顺序
sort（函数（xx，yy）{return Math.floor（Math.random（）*3）-1；}）
函数getNextRandom（）{
返回grabBag.shift（）；
};
var originalLength=grabBag.length；
对于（变量i=0；i

这当然会破坏原始grabBag阵列。我不确定这种排序是否“真正随机”，但对于许多应用程序来说，它可能“足够好”

---

稍微不同的方法是将所有未使用的元素存储在一个数组中，随机选择一个索引，然后删除该索引处的元素。这里的成本是每次删除元素时创建/销毁阵列的频率。

以下是使用Matt grabBag技术的几个版本：

function getRandoms(numPicks) {
    var nums = [1,2,3,4,5,6,7,8,9,10];
    var selections = [];

    // randomly pick one from the array
    for (var i = 0; i < numPicks; i++) {
        var index = Math.floor(Math.random() * nums.length);
        selections.push(nums[index]);
        nums.splice(index, 1);
    }
    return(selections);
}

函数getRandoms（numPicks）{ var nums=[1,2,3,4,5,6,7,8,9,10]； var选择=[]； //从数组中随机选取一个 对于（变量i=0；i 您可以看到它在这里工作：

这里有一个版本，可以让你在你想要覆盖的范围内通过：

function getRandoms(numPicks, low, high) {
    var len = high - low + 1;
    var nums = new Array(len);
    var selections = [], i;
    // initialize the array
    for (i = 0; i < len; i++) {
        nums[i] = i + low;
    }

    // randomly pick one from the array
    for (var i = 0; i < numPicks; i++) {
        var index = Math.floor(Math.random() * nums.length);
        selections.push(nums[index]);
        nums.splice(index, 1);
    }
    return(selections);
}

函数getRandoms（numPicks、low、high）{ var len=高-低+1； var nums=新阵列（len）； var选择=[]，i； //初始化数组 对于（i=0；i

---

还有一把小提琴：

我在使用递归函数。测试函数选择1和9之间的6个唯一值

//test(1, 9, 6);

function test(min, max, nbValue){
    var result = recursValue(min, max, nbValue, []);
    alert(result);
}

function recursValue(min, max, nbValue, result){
    var randomNum = Math.random() * (max-min);
    randomNum = Math.round(randomNum) + min;

    if(!in_array(randomNum, result)){
        result.push(randomNum);
        nbValue--;
    }

    if(nbValue>0){
        recursValue(min, max, nbValue, result);
    }
    return result;
}

function in_array(value, my_array){
    for(var i=0;i< my_array.length; i++){
        if(my_array[i] == value){
            console.log(my_array+" val "+value);
            return true;   
        }        
    }
    return false;
}

//测试（1,9,6）；
功能测试（最小值、最大值、最大值）{
var结果=递归值（最小值、最大值、nbValue、[]）；
警报（结果）；
}
函数递归值（最小值、最大值、nbValue、结果）{
var randomNum=Math.random（）*（max-min）；
randomNum=数学轮（randomNum）+min；
if（！in_数组（randomNum，result））{
结果：推送（随机数）；
nbValue--；
}
如果（值>0）{
递归值（最小值、最大值、nbValue、结果）；
}
返回结果；
}
_数组中的函数（值，我的_数组）{
对于（var i=0；i

这是一个递归函数，您正在寻找它

"howMany" parameter is count of how many unique numbers you want to generate.
"randomize" parameter is biggest number that function can generate.

例如：rand（4,8）函数返回一个数组，其中包含4个数字，数字介于0和7之间（因为正如您所知，Math.random（）函数生成从0到[给定数字-1]的数字）

var数组=[]；
var isMatch=错误；
函数随机数（多少，随机化）{
if（array.length<多少）{
var r=Math.floor（Math.random（）*随机化）；
对于（变量i=0；i<多少；i++）{
if（数组[i]！==r）{
isMatch=false；
继续；
}否则{
isMatch=true；
打破
}
}
如果（isMatch==false）{
推（r）；
ran（多少，随机化）；
}
ran（多少，随机化）；
返回数组；
}
}

在您的回答中，您确实有一个小错误。而不是

var originalLength = grabBag.length;
for(var i = 0; i < originalLength .length; i++){
    console.log(getNextRandom());
}

var originalLength=grabBag.length；
对于（变量i=0；i

我相信你的意思是：

var originalLength = grabBag.length;
for(var i = 0; i < originalLength; i++){
    console.log(getNextRandom());
}

v
var originalLength = grabBag.length;
for(var i = 0; i < originalLength .length; i++){
    console.log(getNextRandom());
}

var originalLength = grabBag.length;
for(var i = 0; i < originalLength; i++){
    console.log(getNextRandom());
}