Javascript 随机化阵列，拾取2个随机对象，然后填充新阵列？

例如，我有一个包含多个对象的数组

var arr = ["a", "b", "c", "d"];

我想要的是从该数组中拾取两个随机对象，例如“a”和“c”，然后将这两个对象推到另一个数组中，例如“arrCopy”。 另一件事是，我想要数组“arrCopy”中元素的副本，这些元素也被洗牌。因此，该数组应该如下所示：

arrCopy = ["c", "a", "a", "c"];

最后，如果它们的内容相同，我如何比较它们？例如：

arrCopy[1] == arrCopy[2];

---

使用任意随机化算法（例如：fisher-yates算法）

随机化阵列中的对象并

选择任意两个元素，如

var firstElement = arr[Math.floor(Math.random()*arr.length)]
var secElement = arr[Math.floor(Math.random()*arr.length)]

---

关于你的第一个问题：

var index1 = parseInt(Math.random() * arr.length, 10);
var index2 = index1;
while(index1 == index2) {
  index2 = parseInt(Math.random() * arr.length, 10)
}

var arrCopy = [arr[index1], arr[index2]]

你能澄清你问题的第二部分吗，这听起来不像‘另一件事是，我想让数组中元素的副本‘arrCopy’与你的示例相符，因为你的示例有4个元素，而不是你从数组中选择的2个

编辑：

关于第二个问题，请替换：

var arrCopy = [arr[index1], arr[index2]]

与：

关于你的第三个问题：

arrCopy1==arrCopy2将是浅层比较（它们在内存中的地址是否相同）

var areEqual=true；
对于（变量i=0；i

---

然后检查areEual是否存在深度相等（数组内容是否相同）。

从中找到了一种最简单的方法。

。排序有助于以较短的方式完成此操作

[1,2,3,4,5,6].sort(function() {
  return .5 - Math.random();
});

这应该可以做到：

function shuffle(array) {
  var currentIndex = array.length
    , temporaryValue
    , randomIndex
    ;

  // While there remain elements to shuffle...
  while (0 !== currentIndex) {

    // Pick a remaining element...
    randomIndex = Math.floor(Math.random() * currentIndex);
    currentIndex -= 1;

    // And swap it with the current element.
    temporaryValue = array[currentIndex];
    array[currentIndex] = array[randomIndex];
    array[randomIndex] = temporaryValue;
  }

  return array;
}

var arr = [{a:{count:3}}, {b:{count:2}}, {c:{count:3}}, {d:{count:4}}];

var num1,num2;
var shuffled_arr=shuffle(arr);
item1=arr[0];
item2=arr[1];

var arrCopy=shuffle([item1,item2,item1,item2]);

for(var i=0;i<arrCopy.length;i++){
    for(var g=i+1;g<arrCopy.length;g++){
        if(JSON.stringify(arrCopy[i])==JSON.stringify(arrCopy[g])){
            console.log('item in index ' + i +' is equal to item in index '+ g)
            console.log(arrCopy[i], arrCopy[g])
        }
    }    
}

函数洗牌（数组）{
var currentIndex=array.length
，时间价值
，随机指数
;
//虽然还有一些元素需要洗牌。。。
而（0！==currentIndex）{
//选择剩余的元素。。。
randomIndex=Math.floor（Math.random（）*currentIndex）；
currentIndex-=1；
//并将其与当前元素交换。
临时值=数组[currentIndex]；
数组[currentIndex]=数组[randomIndex]；
数组[randomIndex]=临时值；
}
返回数组；
}
var arr=[{a:{count:3}，{b:{count:2}，{c:{count:3}，{d:{count:4}]；
变量num1，num2；
var shuffled_arr=随机（arr）；
第1项=arr[0]；
第2项=arr[1]；
var arrCopy=shuffle（[item1，item2，item1，item2]）；
对于（var i=0；i可能的重复：？这意味着：获取2个随机元素[a，c]，将它们推送到另一个数组中，并复制它们，因此新数组将有4个元素[a，c，a，c]，注意，这将返回一个随机数组——而不是单个值（或作为OP请求返回两个值）。这看起来不错，但我如何比较这两项的值？@user3652674这两项是数字、字符串、数组、对象还是什么？
[1,2,3,4,5,6].sort(function() {
  return .5 - Math.random();
});

function shuffle(array) {
  var currentIndex = array.length
    , temporaryValue
    , randomIndex
    ;

  // While there remain elements to shuffle...
  while (0 !== currentIndex) {

    // Pick a remaining element...
    randomIndex = Math.floor(Math.random() * currentIndex);
    currentIndex -= 1;

    // And swap it with the current element.
    temporaryValue = array[currentIndex];
    array[currentIndex] = array[randomIndex];
    array[randomIndex] = temporaryValue;
  }

  return array;
}

var arr = [{a:{count:3}}, {b:{count:2}}, {c:{count:3}}, {d:{count:4}}];

var num1,num2;
var shuffled_arr=shuffle(arr);
item1=arr[0];
item2=arr[1];

var arrCopy=shuffle([item1,item2,item1,item2]);

for(var i=0;i<arrCopy.length;i++){
    for(var g=i+1;g<arrCopy.length;g++){
        if(JSON.stringify(arrCopy[i])==JSON.stringify(arrCopy[g])){
            console.log('item in index ' + i +' is equal to item in index '+ g)
            console.log(arrCopy[i], arrCopy[g])
        }
    }    
}