Question

如果有任何意义，我有一个包含数组数组的数组。例如：

[[1, 2, 3], [2, 3, 4], [3, 4, 5], [4, 5, 6]]

我想看一个数组是否存在数组，所以如果[1,2,3]完全重复。我曾尝试使用.indexOf方法，但确实找到了副本。我也尝试过Extjs手动遍历数组并评估每个内部数组，这就是我做的方式：

var arrayToSearch = [[1, 2, 3], [2, 3, 4], [3, 4, 5], [4, 5, 6]];        
var newArray = [1, 2, 3];
Ext.each(arrayToSearch, function(entry, index){
                    console.log(newArray, entry);
                    if(newArray == entry){
                        console.log(index);
                    };
                });

这也没有检测到重复。 console.log将输出[1,2,3]和[1,2,3]但不会将它们识别为相等。我也尝试了===评估器，但显然因为==不起作用===不会工作。我有智慧，有任何建议。

Answer 1

使用==或===比较两个数组将不起作用，因为它们不是同一个对象。如果要确定两个数组的元素相等，则需要逐个元素地比较数组。

我怀疑你会从使用join(',')这样的技巧然后使用字符串操作获得任何收益。以下应该可以工作：

function arraysAreEqual (a, b) {
  if (a.length != b.length) {
    return false;
  }

  for (var i=0; i<a.length; i++) {
    if (a[i] != b[i]) {
      return false;
    }
  }

  return true;
}

function containsArray (arrays, target) {
  for (var i=0; i<arrays.length; i++) {
    if (arraysAreEqual(arrays[i], target)) {
      return true;
    }
  }

  return false;
}

var arraysToSearch = [[1, 2, 3], [2, 3, 4], [3, 4, 5], [4, 5, 6]];
var newArray = [1, 2, 3];
containsArray(arraysToSearch, newArray);

Answer 2

我经常发现比较两个数组的最佳方法是比较它们的连接值。

if(newArray.join('/') == entry.join('/')) ...

此外，您可能还需要再检查一次：

if(newArray.length == entry.length && newArray.join('/') == entry.join('/'))

如果长度检查无效，那么这是一种非常快速的方法，可以使比较无效，而且不需要进行连接，但检查也提高了比较的可靠性。例如，如果没有长度检查，以下数组在加入时会产生相同的结果：

var a = [1, '2/3'];
var b = [1, 2, 3];

通过长度检查，您确定不会发生类似这样的事情，并且不必担心转义分隔符或其他任何内容......

Answer 3

不幸的是，在一般情况下，你可以判断数组在这种意义上是否相等的唯一方法是比较它们的元素。这样做没有捷径或内置方式。

在某些特殊情况下，您可以使用Array#join并比较结果字符串，例如：

，让您的生活更轻松一些。

var a = [1, 2, 3];
var b = [1, 2, 3];
alert(a.join(",") == b.join(",")); // Alerts "true"

...因为a.join(",")导致字符串“1,2,3”，b.join(",")也是如此。但显然你只有在知道可以连接并比较那些有意义的值时才能这样做。这样做可能会（可能）更快，因为您可以利用JavaScript解释器的内部join和字符串比较方法，但同样，在一般情况下，只有当您使用时才能执行此操作知道数组中的数据可以变成一个字符串并连接起来。

Answer 4

您需要编写一个辅助方法，逐个元素地比较2个数组，并使用它而不是===。

Answer 5

this answer中的代码无法区分以下示例：

javascript:
function sameRAs(newArray,entry){
     return newArray.length == entry.length &&
                                  newArray.join('/') == entry.join('/')};
     alert( sameRAs(  [1,'2/3',4],  [1,2,'3/4']  )  ?  'same' : 'different' );
     alert( sameRAs(    [null],         [,]      )  ?  'same' : 'different' );

要确定[null]和[,]确实不同，请考虑：

 javascript:  alert( [null][0] );  alert( [,][0] );

分别显示null和undefined。

合成数组可以检查数组标识！ ==用于相同的数组！

 javascript:
      ra=[1,2,3]; ar=[4]; r=[]; composite=[ar,r,ra,ar,ra];
      for(i in composite)
         if(composite[i]==ra)
            alert( JSON.stringify(composite) +' at ['+ i +']'+' == ['+ ra +']')

显示：

[[4],[],[1,2,3],[4],[1,2,3]] at [2] == [1,2,3]

和

[[4],[],[1,2,3],[4],[1,2,3]] at [4] == [1,2,3]

虽然我的投票是.toSource（）（＆amp; Mozilla），但可以通过JSON比较简单值数组。

 javascript:
      ra=[1,2,3]; ar=[1,2,3];
      alert([  ra==ar,   JSON.stringify(ra)==JSON.stringify(ar)  ]);

显示false,true。

另一个皱纹：圆形阵列。比较这些很困难，这就是.toSource（）闪耀的地方。

javascript:
   ra = [0,1,2];   ra[3] = ra;      r2d2 = #2= [0,1,2,#2#];
   alert([ ra==r2d2,  ra.toSource() == r2d2.toSource() ])

显示false,true（在FireFox中）。

关于机器效率：与人类时间投入的成本相比，计算费用是微不足道的。计算机可以减少人力，而不是相反。真正计算昂贵且广泛部署的计算可能需要对人力劳动进行大量投资以实现效率。这不是其中之一。

.toSource（）的简单性可能会通过安装FF作为解决此类问题的实用方法来获得回报。问题的规模通常意味着强迫环境和机器获得解决方案而不是使用人工。

Answer 6

本着有趣的挑战，我写了以下功能。它可以工作，并处理（数组，对象，数字，日期，函数和字符串）的简单情况

注意：如果你传递了像{document}这样的东西，你就是为了一个受伤的世界，但简单的东西是有效的。

function compare(a,b){
  if(a instanceof Array && b instanceof Array){
    if(a.length != b.length){
      return false;
    }
    for(var i=0,l=a.length;i<l;i++){
      if(!compare(a[i], b[i])){
      return false;
      }
    }
    return true;
  } else if(typeof(a) == 'object' && typeof(b) == 'object'){
    var keys = {};
    for(var i in a){
      keys[i] = true;
      if(!compare(a[i], b[i])){
      return false;
      }
    }
    //what if b contains a key not in a?
    for(var i in b){
      if(!keys[i]){
      return false;
      }
    }
    return true;
  } else {
    return (a == b);
  }
}

var someDate = new Date();
var someFunc = function(){alert('cheese');};

var foo = {};
foo['a'] = 'asdf';
foo['b'] = 'qwer';
foo['c'] = 'zxcv';
foo['d'] = ['a','b','c','d','e'];
foo['e'] = someDate;
foo['f'] = 34;
foo['g'] = someFunc

var bar = {};
bar['a'] = 'asdf';
bar['b'] = 'qwer';
bar['c'] = 'zx' + 'cv';
bar['d'] = ['a','b','c','d','e'];
bar['e'] = someDate;
bar['f'] = 34;
bar['g'] = someFunc

if(compare(foo, bar)){
  alert('same!');
} else {
  alert('diff!');
}

Answer 7

探索的一种可能的替代方法是使用Array.toSource（）：

>>> [3, 2, 1].toSource() == [3, 2, 1].toSource()
true

评估Javascript数组

7 个答案: