Question

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

array [[array [n]，array [n]，array [n]，etc ...]

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

我有一个我在这里工作的例子http://jsfiddle.net/I_am_Chris/Yn5Wy/

    var randObj1;
    var randObj2;
    var randArray;
    for(i=o; i<array.length; i++){
       randArray = array[i]; //get length of "nested" arrays within the array

      for(n=0;n<randArray.length; n++){
           randObj1 = [][].name
           randObj2 = [][].name
      }
    }

我试过改组阵列，但这只会改变各个阵列，但不是我需要的结果。

Answer 1

好的，听起来你想要N对两个选项，其中对中的每个项目来自不同的数组，你不想重复。

如果您创建一个我们可以从一次选择中删除项目的并行数据结构，那么无重复部分将变得高效并且运行无限循环的风险会降低。这是避免重复的最简单方法，而不必每次都进行搜索。它还允许您轻松知道在任何给定数组中剩余多少选项，以防万一没有更多可能性。这是你如何做到的：

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

工作演示：http://jsfiddle.net/jfriend00/sy6XF/

如果对可以包含任何两个对象，那么这样做更简单。

你有一些看起来像这样的数据（数组数组）：

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

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

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

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

Answer 2

生成一个随机数，使用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;
}

仅供参考，没有对此进行测试，因为不清楚您的测试应该产生什么。

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

2 个答案: