Javascript 在数组数组中生成数组元素的随机显示？

好的，我有一个数组，它至少包含两个或更多可以包含多个对象的数组：

数组[[数组[n]，数组[n]，数组[n]等]

我的问题是如何循环并从数组[0][1]中随机选取一个对象，并从数组[0][15]中随机选取另一个对象，并在将每个对象追加到页面时不产生重复项

我有一个我在这里工作的例子

var-randObj1；
var randObj2；
var阵列；
对于（i=o；iOK），听起来您需要N对两个选项，其中两个选项中的每个项都来自不同的数组，并且不希望重复

如果您创建一个并行数据结构，我们可以从一次选择的数据结构中删除项，则无重复部分将是高效的，并且运行无限循环的风险将更小。这是避免重复的最简单方法，无需每次进行搜索。它还允许您轻松了解cas中任何给定数组中还有多少选择e没有更多的可能性了。以下是您如何做到这一点：

function getPairs(origData, N) {

    // make copy of the data we can modify to keep track of which choices are used
    var copyData = [];
    for (var i = 0; i < origData.length; i++) {
        copyData.push(origData[i].slice(0));
    }

    function getRandomValueAndRemove(skipArray) {
        var randArray;
        // select an array that isn't skipArray
        do {
            randArray = Math.floor(Math.random() * copyData.length);
        } while (randArray === skipArray) ;

        // select an item in that array
        var randIndex = Math.floor(Math.random() * copyData[randArray].length);
        var value = copyData[randArray][randIndex];

        // remove that item from copyData
        copyData[randArray].splice(randIndex, 1);

        // if one of the arrays we selected is now empty, then remove it
        if (!copyData[randArray].length) {
            copyData.splice(randArray, 1);
            // this array is gone so we don't have to worry about selecting it again
            randArray = -1;
        }

        // return data and which array it is
        return {value: value, whichArray: randArray};
    }

    // get N pairs
    var pairs = [];

    for (i = 0; i < N && copyData.length > 1; i++) {
        var item1 = getRandomValueAndRemove();
        var item2 = getRandomValueAndRemove(item1.whichArray);
        pairs.push([item1.value, item2.value]);
    }

    // pairs contains an array of pairs
    // where each item in a pair is from a different source array
    // like this
    //  [[a, b], [c,d], [e,f]]
    return pairs;
}

您可以创建一个包含所有对象的临时单平面阵列。生成一个随机数以获取一个对象。然后，从临时阵列中删除该对象并重复该过程（使用现在较短的阵列）。这是避免重复的最简单方法，因为您将从临时数组中删除已使用的元素，并从其余元素中选择随机选项

下面是第二个选项的代码示例：

var origData = [[...], [...], [...]];
var flatData = [];
var item;

// put everything into flatData
for (var i = 0; i < origData.length; i++) {
    flatData.push.apply(flatData, origData[i]);
}

var pairs = [];
// now select N random pairs
for (var i = 0; i < N && flatData.length > 1; i++) {
    var rand = Math.floor(Math.random() * flatData.length));
    var obj1 = flatData[rand];

    // now remove that element from flatData so we won't pick it again
    flatData.splice(rand, 1);    

    // get second randome value
    rand = Math.floor(Math.random() * flatData.length));
    var obj2 = flatData[rand];

    pairs.push([obj1, obj2]);
}

// pairs contains an array of pairs
[[a, b], [c,d], [e,f]]

var origData=[…]、[…]、[…]；
var flatData=[]；
var项目；
//将所有内容放入flatData
对于（变量i=0；i1；i++）{
var rand=Math.floor（Math.random（）*flatData.length））；
var obj1=扁平数据[rand]；
//现在从flatData中删除该元素，这样我们就不会再拾取它了
flatData.拼接（兰特，1）；
//获取第二个随机值
rand=Math.floor（Math.random（）*flatData.length））；
var obj2=扁平数据[rand]；
成对推送（[obj1，obj2]）；
}
//pairs包含一个pairs数组
[a，b]，[c，d]，[e，f]]
要生成随机数，请使用Math.random（）
Math.random（）生成一个介于0和1之间的随机数。然后乘以嵌套数组的长度，以从嵌套数组中生成所需元素的索引。只要第二个索引等于第一个索引，则重复随机数生成。将结果存储在结果数组中

var results = [];
var genRandNum = function(max) {
  return Math.random() * (max - 1);
}

for(var i = 0; i < array.length; i++) {
  var nestedArray = array[i];

  var randIndex1 = genRandNum(nestedArray.length);
  results.push(nestedArray[randIndex1]);
  do {
    var randIndex2 = genRandNum(nestedArray.length);
  } while (randIndex1 === randIndex2);
  results.push(nestedArray[randIndex2]);
  return results;
}

var结果=[]；
var genRandNum=函数（最大值）{
返回Math.random（）*（最大值为-1）；
}
对于（var i=0；i

仅供参考，之所以没有测试它，是因为不清楚您的测试应该产生什么。
阅读本文，不清楚您究竟是如何尝试这样做的？您想要多对
array[rand1][rand2]
和
array[rand3][rand4]
而不重复使用吗？或者，您希望对总是来自第一个外部数组，如
array[0][rand1]
和
数组[0][rand2]
或者您希望对始终来自相同但随机的外部数组，例如来自
数组[rand1][rand2]
和
数组[rand1][rand3]
？@vdua-我想我可能已经读过了……它只是解释了如何洗牌数组中的单个数组！我希望在数组中循环，并从没有任何重复的单独数组中提取两个随机对象。@jfriend00-我正在从数组[rand3][rand1]中查找对。名称与数组[rand1][rand2]配对.name no repeats！@Chris:在洗牌数组之后，你会得到元素的随机顺序。然后你可以迭代数组。我认为你会得到想要的结果。只有当你的最终结果是显示数组的随机顺序时，这才有效。我想做的是将两个学生（对象）从不同的教室（数组）配对在一起，因此我宁愿不创建单个平面数组…即使我可以通过以下方式找到如何将它们配对：数组[0][1]。名称与数组[0][2]配对。name@Chris-你的问题不太清楚你想做什么。你想要多对
array[rand1][rand2]
和
array[rand3][rand4]
在所有随机数都可能不同的情况下不进行重用？或者，您希望对总是来自第一个外部数组，比如来自
数组[0][rand1]
和
数组[0][rand2]
或者您希望对总是来自相同的外部数组，比如来自
数组[rand1][rand2]
和
数组[rand1][rand3]
？我正在从ie中寻找配对，数组[rand3][rand1]。名称与数组[rand1][rand2]配对。从不同源数组生成的名称无重复！@Chris-好，我添加了一个新选项（显示为我答案中的第一个选项）这将选择N对，其中每一项都来自不同的数组，没有重复。@Chris-修复了一些错误，并为第一个选项添加了一个工作的JSFIDLE。
var origData = [[...], [...], [...]];
var flatData = [];
var item;

// put everything into flatData
for (var i = 0; i < origData.length; i++) {
    flatData.push.apply(flatData, origData[i]);
}

var pairs = [];
// now select N random pairs
for (var i = 0; i < N && flatData.length > 1; i++) {
    var rand = Math.floor(Math.random() * flatData.length));
    var obj1 = flatData[rand];

    // now remove that element from flatData so we won't pick it again
    flatData.splice(rand, 1);    

    // get second randome value
    rand = Math.floor(Math.random() * flatData.length));
    var obj2 = flatData[rand];

    pairs.push([obj1, obj2]);
}

// pairs contains an array of pairs
[[a, b], [c,d], [e,f]]

var results = [];
var genRandNum = function(max) {
  return Math.random() * (max - 1);
}

for(var i = 0; i < array.length; i++) {
  var nestedArray = array[i];

  var randIndex1 = genRandNum(nestedArray.length);
  results.push(nestedArray[randIndex1]);
  do {
    var randIndex2 = genRandNum(nestedArray.length);
  } while (randIndex1 === randIndex2);
  results.push(nestedArray[randIndex2]);
  return results;
}