使用jQuery比较两个Javascript对象数组

我有两个JavaScript对象数组，我想比较它们是否相同。对象在每个数组中的顺序可能不相同（很可能也不相同）。每个数组不应包含超过10个对象。我认为jQuery可能有一个优雅的解决方案来解决这个问题，但我在网上找不到太多

我知道一个暴力嵌套的

$。每个（数组，函数（）{}）

解决方案都可以工作，但是有没有我不知道的内置函数

---

谢谢。

我认为没有一个好的“jQuery”方法可以做到这一点，但是如果您需要效率，可以通过某个键（唯一的对象字段之一）映射其中一个数组，然后通过循环另一个数组并与您刚刚构建的映射或关联数组进行比较来进行比较

---

如果效率不是问题，只需将A中的每个对象与B中的每个对象进行比较。只要| A |和| B |较小，就可以了。

如果您只想比较数组的内容，那么有一个有用的jQuery函数

---

我今天也在找这个，发现：

不知道这是否是一个好的解决方案，尽管他们确实提到了一些性能方面的考虑

我喜欢jQuery助手方法的想法。 @David我希望看到您的比较方法的工作方式如下：

jQuery.compare(a, b)

我没有理由这样做：

$(a).compare(b)

其中a和b是数组。通常，当您$（某物）时，您将传递一个选择器字符串来处理DOM元素

关于排序和“缓存”排序的数组：

• 我不认为在方法开始时排序一次而不是每次通过循环都是“缓存”。每次调用compare（b）时，排序仍然会发生。这只是语义学，但是
• 对于（var i=0；t[i]；i++）{…如果t数组中的某个地方包含一个假值，则此循环将提前结束，因此$（[1，2，3，4]）。比较（[1，false，2，3]）返回真
• 更重要的是，array sort（）方法在适当的位置对数组进行排序，因此执行var b=t.sort（）…不会创建原始数组的排序副本，它会对原始数组进行排序，并在b中为其指定一个引用。我认为比较方法不应该有副作用

似乎我们需要做的是在处理数组之前复制它们。我能找到的关于如何以jQuery方式实现这一点的最佳答案就是John Resig（参见他回答中的注释，了解对象克隆配方的数组版本）

在这种情况下，我认为代码应该是：

jQuery.extend({
    compare: function (arrayA, arrayB) {
        if (arrayA.length != arrayB.length) { return false; }
        // sort modifies original array
        // (which are passed by reference to our method!)
        // so clone the arrays before sorting
        var a = jQuery.extend(true, [], arrayA);
        var b = jQuery.extend(true, [], arrayB);
        a.sort(); 
        b.sort();
        for (var i = 0, l = a.length; i < l; i++) {
            if (a[i] !== b[i]) { 
                return false;
            }
        }
        return true;
    }
});

var a = [1, 2, 3];
var b = [2, 3, 4];
var c = [3, 4, 2];

jQuery.compare(a, b);
// false

jQuery.compare(b, c);
// true

// c is still unsorted [3, 4, 2]

jQuery.extend({
比较：函数（arrayA、arrayB）{
如果（arrayA.length！=arrayB.length）{return false；}
//排序修改原始数组
//（通过引用我们的方法传递！）
//所以在排序之前克隆数组
var a=jQuery.extend（true，[]，arrayA）；
var b=jQuery.extend（true，[]，arrayB）；
a、 排序（）；
b、 排序（）；
对于（变量i=0，l=a.length；i

我找到了这个讨论，因为我需要一种深入比较数组和对象的方法。通过这里的示例，我提出了以下方法（为了清晰起见分为3种方法）：

---

有一个简单的方法

$(arr1).not(arr2).length === 0 && $(arr2).not(arr1).length === 0

如果上述返回true，则即使元素顺序不同，两个数组也是相同的

注意：当使用JSON对象时，这仅适用于jquery版本<3.0.0

function check(c,d){
  var a = c, b = d,flg = 0;
  if(a.length == b.length) 
  { 
     for(var i=0;i<a.length;i++) 
           a[i] != b[i] ? flg++ : 0; 
  } 
  else  
  { 
     flg = 1; 
  } 
  return flg = 0;
}

功能检查（c、d）{
变量a=c，b=d，flg=0；
如果（a.length==b.length）
{ 
对于（var i=0；ias jQuery全局方法中的尼斯一行

/**
 * Compare two arrays if they are equal even if they have different order.
 *
 * @link https://stackoverflow.com/a/7726509
 */
jQuery.extend({
  /**
   * @param {array} a
   *   First array to compare.
   * @param {array} b
   *   Second array to compare.
   * @return {boolean}
   *   True if both arrays are equal, otherwise false.
   */
  arrayCompare: function (a, b) {
    return $(a).not(b).get().length === 0 && $(b).not(a).get().length === 0;
  }
});

我的方法完全不同——我使用JSON.stringify将两个集合展平，并使用普通字符串比较来检查相等性

即

注意：请注意，他的方法假设两个集合都以相似的方式排序，如果没有，则会给出错误的结果！
我在与jQuery进行数组比较时也发现了这一点。在我的例子中，我有一些字符串，我知道它们是数组：

var needle = 'apple orange';
var haystack = 'kiwi orange banana apple plum';

但我关心的是完全匹配还是部分匹配，所以根据苏达卡尔的回答，我使用了如下内容：

function compareStrings( needle, haystack ){
  var needleArr = needle.split(" "),
    haystackArr = haystack.split(" "),
    compare = $(haystackArr).not(needleArr).get().length;

  if( compare == 0 ){
    return 'all';
  } else if ( compare == haystackArr.length  ) {
    return 'none';
  } else {
    return 'partial';
  }
}

在我的例子中，比较数组只包含数字和字符串。此解决方案对我有效：

function are_arrs_equal(arr1, arr2){
    return arr1.sort().toString() === arr2.sort().toString()
}

让我们测试一下

arr1 = [1, 2, 3, 'nik']
arr2 = ['nik', 3, 1, 2]
arr3 = [1, 2, 5]

console.log (are_arrs_equal(arr1, arr2)) //true
console.log (are_arrs_equal(arr1, arr3)) //false

将数组更改为字符串并进行比较

var arr = [1,2,3], 
arr2 = [1,2,3]; 
console.log(arr.toString() === arr2.toString());

if (JSON.stringify(array1) == JSON.stringify(array2))
{
    // your code here
}

将两个数组转换为字符串并进行比较

var arr = [1,2,3], 
arr2 = [1,2,3]; 
console.log(arr.toString() === arr2.toString());

if (JSON.stringify(array1) == JSON.stringify(array2))
{
    // your code here
}

如果重复项很重要，以至于
[1,1,2]
不应等于
[2,1]
，而应等于
[1,2,1]
，以下是参考计数解决方案：

  const arrayContentsEqual = (arrayA, arrayB) => {
    if (arrayA.length !== arrayB.length) {
      return false}

    const refCount = (function() {
      const refCountMap = {};
      const refCountFn = (elt, count) => {
          refCountMap[elt] = (refCountMap[elt] || 0) + count}
      refCountFn.isZero = () => {
        for (let elt in refCountMap) {
          if (refCountMap[elt] !== 0) {
            return false}}
        return true}
      return refCountFn})()

    arrayB.map(eltB => refCount(eltB, 1));
    arrayA.map(eltA => refCount(eltA, -1));
    return refCount.isZero()}

.

var arr1=[
{name:'a'，Val:1}，
{name:'b'，Val:2}，
{name:'c'，Val:3}
];
var arr2=[
{name:'c'，Val:3}，
{name:'x'，Val:4}，
{name:'y'，Val:5}，
{name:'z'，Val:6}
];
var _isEqual=u.intersectionWith（arr1，arr2，u.isEqual）；//在两个数组中都是公共的
var_difference1=u.differenceWith（arr1，arr2，u.isEqual）；//与array1的差异
var _difference2=u.differenceWith（arr2，arr1，u.isEqual）；//与array2的差异
console.log（_isEqual）；//在两个数组中都是公共的
console.log（_difference1）；//与数组1的差异
console.log（_difference2）；//与array2的差异
@Stefan，感谢您的快速响应。您能为您的映射想法发布示例代码吗？谢谢。这是一个很好的解决方案，但我不确定这是因为数组具有相同的元素，但顺序不同。如果（！equal）return false；，您可以移动到$的底部。每个都可以避免引发乐趣
if (JSON.stringify(array1) == JSON.stringify(array2))
{
    // your code here
}

  const arrayContentsEqual = (arrayA, arrayB) => {
    if (arrayA.length !== arrayB.length) {
      return false}

    const refCount = (function() {
      const refCountMap = {};
      const refCountFn = (elt, count) => {
          refCountMap[elt] = (refCountMap[elt] || 0) + count}
      refCountFn.isZero = () => {
        for (let elt in refCountMap) {
          if (refCountMap[elt] !== 0) {
            return false}}
        return true}
      return refCountFn})()

    arrayB.map(eltB => refCount(eltB, 1));
    arrayA.map(eltA => refCount(eltA, -1));
    return refCount.isZero()}