Javascript条件回调

我目前正在使用javascript做一些实验，虽然我对JS并不陌生，但我怀疑，我希望SO的好人能够提供帮助

基本上，我向一个Web服务发出一个jsonp请求，返回回复中的数量/长度（只计算对象）。 然后我随机选择其中的9个对象放置在一个数组中，问题就在这里。我想确保这9个对象中没有一个是重复的。 为了实现这一点，我使用以下代码：

function randomizer() {
    return Math.ceil(Math.random()*badges.length);
}

function dupsVerify(array, number) {
    array.forEach(function () {
        if(array === number) {
            return true;
        }
    });
    return false;
}

// Randomly choose 9 array indexes
var randomBadge = function () {
var selectedIndexes = new Array();

while(selectedIndexes.length < 9) {
    var found = false;
    var randomNumber = randomizer();

    if(!dupsVerify(selectedIndexes, randomNumber)) {
        selectedIndexes.push(randomNumber);
    } else {
        newRandom = randomizer();
        dupsVerify(selectedIndexes, newRandom);
    }
}
return selectedIndexes;
}

function randomizer() {
    return Math.ceil(Math.random()*badges.length);
}

function dupsVerify(array, number) {
    var result;
    if(array.length === 0) {result = false;}
        array.forEach(function (item) {
            if(item === number) {
                result = true;
            } else {
                result = false;
            }
        });
    return result;
}

// Randomly choose 9 array indexes
function randomBadge() {

    while(cards.length < 9) {
        var randomNumber = randomizer();
        if(!dupsVerify(cards, randomNumber)) {
            cards.push(randomNumber);
        } else {
            randomBadge();
        }
    }
    return cards;
}

函数随机化器（）{
返回Math.ceil（Math.random（）*badges.length）；
}
函数dupsVerify（数组、数字）{
array.forEach（函数（）{
如果（数组===数字）{
返回true；
}
});
返回false；
}
//随机选择9个数组索引
var randomBadge=函数（）{
var selectedIndex=新数组（）；
while（selectedIndex.length<9）{
var=false；
var randomNumber=随机化器（）；
如果（！dupsVerify（SelectedIndex，randomNumber））{
选择索引。推送（随机数）；
}否则{
newRandom=randomizer（）；
重复验证（选择索引，新随机）；
}
}
返回所选索引；
}

我尝试了几种不同的方法来进行验证，但我一直在想，如果无法做到以下几点：

生成随机数并遍历数组以验证它是否已存在于数组中。如果存在，则生成另一个随机数（随机调用）并再次验证。。如果它在数组中不存在，则将其推送到“final”数组

我怎样才能做到这一点？使用回调？ 我这样做是对的，还是应该冒险修改代码？有没有更简单的方法

---

致以最诚挚的问候，

这将使您获得所需的行为：

function getRandomPositions(sourcearray, desiredcount){
   var result = [];

   while(result.lentgth < desiredcount){
       var rnd = Math.ceil(Math.random()*sourcearray.length);
       if (result.indexOf(rnd) == -1){
            result.push(rnd);
       }
   }
    return result;
}

函数getRandomPositions（sourcearray，desiredcount）{ var结果=[]； while（result.lentgth

---

不要生成X个随机数，只需生成一个随机数，但如果它已经存在，则不要添加它。

这将获得所需的行为：

function getRandomPositions(sourcearray, desiredcount){
   var result = [];

   while(result.lentgth < desiredcount){
       var rnd = Math.ceil(Math.random()*sourcearray.length);
       if (result.indexOf(rnd) == -1){
            result.push(rnd);
       }
   }
    return result;
}

函数getRandomPositions（sourcearray，desiredcount）{ var结果=[]； while（result.lentgth

---

不要生成X个随机数，只需生成一个随机数，但如果它已经存在，则不要添加它。

我最终使用以下代码找到了此方案的最佳解决方案：

function randomizer() {
    return Math.ceil(Math.random()*badges.length);
}

function dupsVerify(array, number) {
    array.forEach(function () {
        if(array === number) {
            return true;
        }
    });
    return false;
}

// Randomly choose 9 array indexes
var randomBadge = function () {
var selectedIndexes = new Array();

while(selectedIndexes.length < 9) {
    var found = false;
    var randomNumber = randomizer();

    if(!dupsVerify(selectedIndexes, randomNumber)) {
        selectedIndexes.push(randomNumber);
    } else {
        newRandom = randomizer();
        dupsVerify(selectedIndexes, newRandom);
    }
}
return selectedIndexes;
}

function randomizer() {
    return Math.ceil(Math.random()*badges.length);
}

function dupsVerify(array, number) {
    var result;
    if(array.length === 0) {result = false;}
        array.forEach(function (item) {
            if(item === number) {
                result = true;
            } else {
                result = false;
            }
        });
    return result;
}

// Randomly choose 9 array indexes
function randomBadge() {

    while(cards.length < 9) {
        var randomNumber = randomizer();
        if(!dupsVerify(cards, randomNumber)) {
            cards.push(randomNumber);
        } else {
            randomBadge();
        }
    }
    return cards;
}

函数随机化器（）{
返回Math.ceil（Math.random（）*badges.length）；
}
函数dupsVerify（数组、数字）{
var结果；
如果（array.length==0）{result=false；}
array.forEach（函数（项）{
如果（项目==编号）{
结果=真；
}否则{
结果=假；
}
});
返回结果；
}
//随机选择9个数组索引
函数randomBadge（）{
while（卡片长度<9）{
var randomNumber=随机化器（）；
如果（！dupsVerify（卡片、随机编号））{
卡片。推送（随机编号）；
}否则{
随机标记（）；
}
}
回程卡；
}

---

这表示了相同的行为（以及一些次要的代码更正），但确保了我永远不会得到包含2个重复对象的数组。

我最终使用以下代码找到了此场景的最佳解决方案：

function randomizer() {
    return Math.ceil(Math.random()*badges.length);
}

function dupsVerify(array, number) {
    array.forEach(function () {
        if(array === number) {
            return true;
        }
    });
    return false;
}

// Randomly choose 9 array indexes
var randomBadge = function () {
var selectedIndexes = new Array();

while(selectedIndexes.length < 9) {
    var found = false;
    var randomNumber = randomizer();

    if(!dupsVerify(selectedIndexes, randomNumber)) {
        selectedIndexes.push(randomNumber);
    } else {
        newRandom = randomizer();
        dupsVerify(selectedIndexes, newRandom);
    }
}
return selectedIndexes;
}

function randomizer() {
    return Math.ceil(Math.random()*badges.length);
}

function dupsVerify(array, number) {
    var result;
    if(array.length === 0) {result = false;}
        array.forEach(function (item) {
            if(item === number) {
                result = true;
            } else {
                result = false;
            }
        });
    return result;
}

// Randomly choose 9 array indexes
function randomBadge() {

    while(cards.length < 9) {
        var randomNumber = randomizer();
        if(!dupsVerify(cards, randomNumber)) {
            cards.push(randomNumber);
        } else {
            randomBadge();
        }
    }
    return cards;
}

函数随机化器（）{
返回Math.ceil（Math.random（）*badges.length）；
}
函数dupsVerify（数组、数字）{
var结果；
如果（array.length==0）{result=false；}
array.forEach（函数（项）{
如果（项目==编号）{
结果=真；
}否则{
结果=假；
}
});
返回结果；
}
//随机选择9个数组索引
函数randomBadge（）{
while（卡片长度<9）{
var randomNumber=随机化器（）；
如果（！dupsVerify（卡片、随机编号））{
卡片。推送（随机编号）；
}否则{
随机标记（）；
}
}
回程卡；
}

---

这表示了相同的行为（以及一些小的代码更正），但确保了我永远不会得到一个包含2个重复对象的数组。

通常一个非常好的方法是创建一个数组，其中包含原始数据数组长度中的数字0，将其洗牌，然后使用洗牌数组获得9个要使用的索引。前九个是随机的，不会重叠，因为您从一个非重叠值数组开始。这更像是一个代码检查问题。投票决定就此结束reason@Pointy，我将在代码的更深处执行此操作，但要生成具有相同索引的第二个数组，但被洗牌。这是因为我在做一个记忆游戏，所以我选择了9个初始对象，然后复制它们并洗牌。类似这样的内容：[49,20,13,84,72,63,62,5,49][49,20,84,72,62,5,63,49,13]@EliasVanOotegem这不是一个真正的代码审查问题，而是一个实现目标的最有效/最简单的方法。通常，一个真正好的方法是创建一个数组，包含原始数据数组长度中的数字0，对其进行无序排列，然后使用无序排列的数组获得9个要使用的索引。前九个是随机的，不会重叠，因为您从一个非重叠值数组开始。这更像是一个代码检查问题。投票决定就此结束reason@Pointy，我将在代码的更深处执行此操作，但要生成具有相同索引的第二个数组，但被洗牌。这是因为我在做一个记忆游戏，所以我选择了9个初始对象，然后复制它们并洗牌。李先生