javascript，diff函数返回相同的字符串

Question

我想知道是否有人可以帮助我解决我的差异功能。它应该找到2个输入之间的差异。该函数接受 2 个数组，因此如果数组 1 有..“word1”、“word2”并且数组 2 有“word1”、“word2”和“word3”，它应该只返回“word3”。它在大多数情况下都可以工作，但是使用下面的某些输入，它就不起作用了。

function diff(a1, a2) {

if (a1.length > a2.length
       || a1.length == a2.length) {
    return [""];
}
a1 = a1.slice(0);
a2 = a2.slice(0);


for (i = 0; i < a1.length; i++) {
    for (k = 0; k < a2.length; k++) {
        if (a1[i] == a2[k]) {
            a1.splice(i, 1);
            a2.splice(k, 1);
        }
    }
}

for (j = 0; j < a2.length; j++) {
    for (p = 0; p < a1.length; p++) {
        if (a2[j] == a1[p]) {
            a2.splice(p, 1);
            a1.splice(j, 1);
        }
    }
}


a1 = a1.concat(a2);
return a1;
}

var s1 = ["one", "two", "three", "four",];
var s2 = ["one", "two", "three", "four", "five"];


document.write(diff(s1, s2));

答案应该只返回“五”，但它返回“四”、“四”、“五”。帮助将不胜感激。我超级卡住了。非常感谢！

Answer 1

据我了解，您希望返回一个仅包含两者不同元素的数组。试试这种方式，没有复杂的双循环和拼接等等：

function diff(a1, a2) {

  var aa1 = {}, aa2 = {}, res = [];

  // create an object from a1, containing value:array-index pairs:
  for (var i = 0; i < a1.length; i++) {
      aa1[a1[i]] = i;
  }
  // create an object from a2 like the one from a1
  for (var i = 0; i < a2.length; i++) {
      aa2[a2[i]] = i;
  }
  /**
    * loop through the first object (from a1)
    * if a value in this object is not found in 
    * the object from a2, push that value to 
    * the result array (res)
   */
  for (var l in aa1){
    if (aa1.hasOwnProperty(l) && !(l in aa2)) {
        res.push(a1[aa1[l]]);
    }
  }
  /**
    * but the second array can also contain
    * values differing from the values in the first.
    * So, repeat the above for the object created 
    * from a2
   */
  for (var l in aa2){
   if (aa2.hasOwnProperty(l) && !(l in aa1)) {
        res.push(a2[aa2[l]]);
   }
 }
 /**
   * now res contains all different values
   * note: double values are not counted
   * so ['one','two','tree'] vs ['one','two','four','four']
   * will return ['tree','four']
   * note2: if you want to find the first difference,
   * return res[0]
   */

 return res;
}

如果它只是您想要找到的第一个差异，这个（仅限数组）方法可以：

function diff(a1, a2) {
  var firstdiff = null, i = -1;

  /**
    * local function to check if value [val] 
    * exists in array [arr]. Called from
    * within the loops
    */
  function check(val,arr){
      var i = -1;
      while(++i<arr.length){
          if(val === arr[i]){ return true;}
      }
      return false;
  }
  // loop a1 and check values vs a2-values
  while (++i<a1.length){
    if (!check(a1[i],a2)) {
      return firstdiff = a1[i];
    }
  }
  // no difference found, continue a2 vs a1
  i = -1;
  while (++i<a2.length){
    if (!check(a2[i],a1)) {
      return firstdiff = a2[i];;
    }
  }
  // there are no differences, firstdiff = null
  return firstdiff;
}

Answer 2

问题在于 array.splice 减少了数组的长度，从而使 for 循环跳过了元素。可能的解决方案是减少迭代器。

编辑：

当您拼接数组时，它会从数组中删除元素，使其更短。所以让我们假设我们正在运行这段代码：

test_array = [1, 2, 3, 4, 5];
for(i = 0; i < test_array.length; i++) {
    document.write(test_array[i]);
    if(i == 2) {
        test_array.splice(i, 1);
    }
}

你可以看到它输出的是 1235，而不是 12345。那是因为当 i = 2 并且元素被删除时，数组中的所有元素都重新计算了它们的索引。所以如果在拼接之前数组是：

• [0] = 1
• [1] = 2
• [2] = 3
• [3] = 4
• [4] = 5

之后变成：

• [0] = 1
• [1] = 2
• [2] = 4
• [3] = 5

同时，for 循环移动到 i = 3，但 test_array[3] 不是 4，而是现在 5，因此跳过了数字 4。

一个简单的解决方案是您可以减少迭代器。

例子：

test_array = [1, 2, 3, 4, 5];
for(i = 0; i < test_array.length; i++) {
    document.write(test_array[i]);
    if(i == 2) {
        test_array.splice(i, 1);
        i--;
    }
}

Answer 3

这条评论很快解释了你的代码在做什么：

@Crystal, first double loop: at i=0 k=0 "one"=="one" so each is removed; at i=0 k=1 "two"!="three"; at i=0 k=2 "two"!="four"; at 0 3 "two"!="five"; 1 0 "three"!="two"; 1 1 "three"=="three" so each is removed; 1 2 "four"!="five"; no more cycles. In the second double loop: 0 0 "two"=="two" so each is removed; 0 1 is not run because at this point a1 only has "four" so a1.length==1. Thus we concat "four" in a1 with "four" and "five" in a2

要得到你想要的答案，改变

a1.splice(i, 1);

到

a1.splice(i--, 1);

然后冲洗，重复双循环中的其他 3 个类似情况。因此，您将有 4 种情况，采用拼接并递减第一个参数。这种递减弥补了接头的移除。

但是，您现在只需要其中一个双循环，因为这将消除所有重叠。

另外，为什么要在顶部进行检查以过滤掉 a1 长度大于或等于 a2 长度的情况？也删除该部分。

答案是“五”。如果需要，您可以测试非常不同的数据，它应该可以工作。

所以这可能是你的程序：

function diff(a1, a2) {

a1 = a1.slice(0);
a2 = a2.slice(0);


for (i = 0; i < a1.length; i++) {
    for (k = 0; k < a2.length; k++) {
        if (a1[i] == a2[k]) {
            a1.splice(i--, 1);
            a2.splice(k--, 1);
        }
    }
}


a1 = a1.concat(a2);
return a1;
}

var s1 = ["one", "two", "seven", "three", "four",];
var s2 = ["one", "two", "four", "five", "six"];


document.write(diff(s1, s2));

Answer 4

你在拼接的时候遍历了数组，但是你没有用你的索引来调整它。