javascript - 数组相等 : Issue with duplicates

Question

我已经构建了自己的“数组相等”函数，当数组中的所有值都是唯一的时，它会按预期工作:

示例: (工作)

var
   a = [1, 2, 3, ["a", "b"]],
   b = [1, 2, 3, ["a", "b"]];

arrayEquals(a, b); /* returns: [true, true, true, [true, true]] */

但是，当存在重复值时，最终结果会严重受损:

示例: (无效)

在此示例中， 1 在第一个数组中存在两次。问题是第二个 1 将返回第一个 1 第二个数组作为其匹配项，即使 1 已在一步前与前一个 1 相匹配。 第一个数组。

var
   a = [1, 1, 2],
   b = [1, 2, 2];

arrayEquals(a, b); /* returns: [true, false, false] */
                   /* should return: [true, false, true] */

问题:

有没有办法安全地删除或避免检查匹配的元素，从而改变结果？

<小时/>

我尝试过的:

1) 我尝试按照以下方式删除两个数组中都存在的元素，但不幸的是它没有任何好处:

示例:

if (eachA === eachB) {
   a.splice.call(index, 1); // Removing the matched elements
   b.splice.call(jindex, 1);  // Removing the matched elements
   result[index] = true;
}

2) 我已经尝试过 if (eachA === eachB && !result[index] && !result[jindex]) result[index] = true; 以及认为，如果 result[index] 和 result[jindex] 已经为真，这意味着一个数组中的值已与另一个数组中的值匹配。

<小时/>

代码:

/* Main function */
function arrayEquals(a, b, result) {
  return (a === b && a !== null) || (a.length === b.length &&
    (function check(a, b, result) {
      /* Check equality between 'a' and 'b' arrays */
      a.forEach(function(eachA, index) {
        b.forEach(function(eachB, jindex) {
          if (eachA === eachB) result[index] = true;
          /* Handle objects */
          else if (isObject(eachA) && isObject(eachB))
            result[index] = objectEquals(a, b);
          /* Handle arrays */
          else if (isArray(eachA) && isArray(eachB))
            check(eachA, eachB, (result[index] = []));
          /* Turn all 'undefined' to 'false' */
          else result[index] = (!!result[index]) ? true : false;
        });
      });
      return result;
    })(a, b, (result = [])));
}

/* Usage */
var
  a = [1, 1, 2, ["a", "b"]],
  b = [1, 2, 2, ["a", "b"]];

console.log(arrayEquals(a, b)); /* returns: [true, true, true, [true, true]] */
                                /* should return: [true, false, true, [true, true]] */

/* Supplementary functions */
function isArray(array) {return !!array && array.constructor === Array;}

function isObject(object) {return !!object && object.constructor === Object;}

<小时/>

检查程序:

var
   a = [1, 1, 2],
   b = [1, 2, 2];

• 对于第一个数组的每个索引，我们检查第二个数组的所有索引以逐一找到匹配项。

• 对于第一个数组， 1 (在索引 0 处) 匹配 1 (在索引 0 处) 第二个数组。

• 然后对于第一个数组， 1 (索引 1 处) 与第二个数组的任何索引都不匹配 (索引 0 处的 1 不算，因为我们之前找到了匹配项).

• 最后，对于第一个数组， 2 (在索引 2 处) 匹配 2 (在索引 1 处) 第二个数组。结果:[真、假、真] | 不等于。

摘要:

• 每个索引必须有一个匹配项，可能是相同的索引，也可能是其他索引。

• 如果第二个数组的一个索引用作第一个数组的前一个索引的匹配，则它不能再次用作匹配。

• 相同的元素必须再次存在于另一个索引处才能使用。

图片:

Answer 1

如果保证您的数组具有相同的结构，您可以执行以下操作；

var a = [1, 1, 2, ["a", "b"]],
    b = [1, 2, 2, ["a", "b"]];

function arrayCompare(a,b){
 return a.map((e,i) => Array.isArray(e) ? arrayCompare(e, b[i])
                                        : e === b[i]);
}

console.log(arrayCompare(a,b))