Javascript 比较两个不同长度的数组并返回一个包含不常见元素的数组

这里，我有两个不同长度的数组。一个数组返回的值在两个数组中都不常见。但是编译器给出了错误的输出。这些功能有什么问题？ 输出：[4,5]，而不是[4]

function diffArray(arr1, arr2) {
  var newArr = [];
  var y=[];
  var z=[];
  // Same, same; but different.
  var flag=0;
  for(var i=0;i<arr1.length;i++){
    if(arr2.indexOf(arr1[i]===-1)){
      z=arr1.slice(i,i+1);
      //return z;
    }
    for(var j=0;j<arr2.length;j++){
      if(arr1.indexOf(arr2[j])===-1){
        y=arr2.slice(j,j+1);
        //z=arr1.slice(i,i+1);
        //break;
      }
    }
  }
   return newArr.concat(y,z);
}

diffArray([1, 2, 3, 5], [1, 2, 3, 4, 5]);
diffArray(["diorite", "andesite", "grass", "dirt", "pink wool", "dead shrub"], ["diorite", "andesite", "grass", "dirt", "dead shrub"]);

函数diffArray（arr1、arr2）{
var newArr=[]；
变量y=[]；
var z=[]；
//相同，相同；但不同。
var标志=0；
对于（var i=0；i编写的代码最多只能返回两项，因为每当调用
y
和
z
时，总是用长度为1的新数组覆盖
z=arr1.slice（i，i+1）；
或
y=arr2.slice（j，j+1）；
。您可能需要使用array.push，即
z.push（arr1[i]）；
和
y.push（arr2[j]）；
这将在每次找到元素时添加到同一数组中，而不是每次重置结果数组。
写入的代码最多只能返回两项，因为每当
y
和
z
被长度为1的新数组覆盖时，
z=arr1.slice（i，i+1）；
或
y=arr2.slice（j，j+1）；
被调用。您可能希望使用Array.push，即
z.push（arr1[i]）；
和
y.push（arr2[j]）；
。这将在每次找到元素时添加到同一数组，而不是每次重置结果数组。
尝试以下操作：

function diffArray (arr1, arr2) {
    var z = arr1.filter(function (value) { return !~arr2.indexOf(value); });
    var y = arr2.filter(function (value) { return !~arr1.indexOf(value); });

    return [].concat(y, z);
}

请尝试以下操作：

function diffArray (arr1, arr2) {
    var z = arr1.filter(function (value) { return !~arr2.indexOf(value); });
    var y = arr2.filter(function (value) { return !~arr1.indexOf(value); });

    return [].concat(y, z);
}

您可以为您的功能尝试一种替代方案

a1 = [1, 2, 3, 5];
a2 = [1, 2, 3, 4, 5];
result = [];
if (a1.length > a2.length) {
  temp = a1;
  a1 = a2;
  a2 = temp;
}

$.grep(a2, function(k) {
        if ($.inArray(k, a1) == -1) result.push(k);
});
console.log(result);,

这是两个数组集的工作方式

试一试，这就行了。
您可以为您的功能尝试一种替代方案

a1 = [1, 2, 3, 5];
a2 = [1, 2, 3, 4, 5];
result = [];
if (a1.length > a2.length) {
  temp = a1;
  a1 = a2;
  a2 = temp;
}

$.grep(a2, function(k) {
        if ($.inArray(k, a1) == -1) result.push(k);
});
console.log(result);,

这是两个数组集的工作方式

试试看，这会有用。
您可以合并数组并返回唯一值


函数diffArray（a1、a2）{
var数据=a1.concat（a2）；
返回数据.filter（函数（项，i，a）{
返回a.indexOf（项目）==a.lastIndexOf（项目）
});
}
log（diffArray（[1,2,3,5]，[1,2,3,4,5]）；
log（diffArray（[1,2,3,5]，[11,12,13,14,5]）；
您可以合并数组并返回唯一值


函数diffArray（a1、a2）{
var数据=a1.concat（a2）；
返回数据.filter（函数（项，i，a）{
返回a.indexOf（项目）==a.lastIndexOf（项目）
});
}
log（diffArray（[1,2,3,5]，[1,2,3,4,5]）；
log（diffArray（[1,2,3,5]，[11,12,13,14,5]）；
试试这个

var newArr = [];
    function diffArray(arr1, arr2) {


            arr1.forEach(function (item) {
                if (arr2.indexOf(item) === -1)
                    newArr.push(item);
            });

            arr2.forEach(function (item) {
                if (arr1.indexOf(item) === -1)
                    newArr.push(item);
            });

    }

    diffArray(["andesite", "grass", "dirt", "pink wool", "dead shrub"], ["diorite", "andesite", "grass", "dirt", "dead shrub"]);

试试这个

var newArr = [];
    function diffArray(arr1, arr2) {


            arr1.forEach(function (item) {
                if (arr2.indexOf(item) === -1)
                    newArr.push(item);
            });

            arr2.forEach(function (item) {
                if (arr1.indexOf(item) === -1)
                    newArr.push(item);
            });

    }

    diffArray(["andesite", "grass", "dirt", "pink wool", "dead shrub"], ["diorite", "andesite", "grass", "dirt", "dead shrub"]);

在代码中有如下行：

z=arr1.slice(i,i+1);
y=arr2.slice(j,j+1);

如果这样做，每次获得一个唯一的元素时，就会丢失先前存储的元素

另外，
Array.prototype.slice
返回一个数组，因此也不需要使用
slice（）

function diffArray(arr1, arr2) {
  var newArr = [];
  var y=[];
  var z=[];

  var flag=0;
  for(var i=0;i<arr1.length;i++) {
    if(arr2.indexOf(arr1[i])===-1) {
      z.push(arr1[i]);
    }
  }

  for(var j=0;j<arr2.length;j++) {
    if(arr1.indexOf(arr2[j])===-1) {
      y.push(arr2[j]);
    }
  }

  return y.concat(z);
}

函数diffArray（arr1、arr2）{
var newArr=[]；
变量y=[]；
var z=[]；
var标志=0；
对于（var i=0；i）来说，我将显示相同的值。
在您的代码中，有如下行：

z=arr1.slice(i,i+1);
y=arr2.slice(j,j+1);

function diffArray(arr1, arr2) {
  var newArr = [];

  var firstArray = arr1;
  var secondArray = arr2;
  if (arr2.length > arr1.length) {
    firstArray = arr2;
    secondArray = arr1;
  }

  var isNotMatched = false;

  for (var i in firstArray) {
    for (var j in secondArray) {
      if (firstArray[i] !== secondArray[j]) {
        isNotMatched = true;
      } else {
        isNotMatched = false;
        break;
      }

    }

    if (isNotMatched)
      newArr.push(firstArray[i]);

  }

  return newArr;
}

diffArray([1, 2, 3, 5], [1, 2, 3, 4, 5]);

如果这样做，每次获得一个唯一的元素时，就会丢失先前存储的元素

另外，
Array.prototype.slice
返回一个数组，因此也不需要使用
slice（）

function diffArray(arr1, arr2) {
  var newArr = [];
  var y=[];
  var z=[];

  var flag=0;
  for(var i=0;i<arr1.length;i++) {
    if(arr2.indexOf(arr1[i])===-1) {
      z.push(arr1[i]);
    }
  }

  for(var j=0;j<arr2.length;j++) {
    if(arr1.indexOf(arr2[j])===-1) {
      y.push(arr2[j]);
    }
  }

  return y.concat(z);
}

函数diffArray（arr1、arr2）{
var newArr=[]；
变量y=[]；
var z=[]；
var标志=0；
对于（var i=0；i），则显示相同的值

function diffArray(arr1, arr2) {
  var newArr = [];

  var firstArray = arr1;
  var secondArray = arr2;
  if (arr2.length > arr1.length) {
    firstArray = arr2;
    secondArray = arr1;
  }

  var isNotMatched = false;

  for (var i in firstArray) {
    for (var j in secondArray) {
      if (firstArray[i] !== secondArray[j]) {
        isNotMatched = true;
      } else {
        isNotMatched = false;
        break;
      }

    }

    if (isNotMatched)
      newArr.push(firstArray[i]);

  }

  return newArr;
}

diffArray([1, 2, 3, 5], [1, 2, 3, 4, 5]);

第二版适用于所有人

function diffArray(arr1, arr2) {
  var newArr = [];
  var firstArray = arr1;
  var secondArray = arr2;
  if (arr2.length > arr1.length) {
    firstArray = arr2;
    secondArray = arr1;
  }

  var whenSameLegth = '';
  var isNotMatched = false;

  for (var i in firstArray) {
    for (var j in secondArray) {
      if (firstArray[i] !== secondArray[j]) {
        isNotMatched = true;
        whenSameLegth = secondArray[j];
      } else {
        isNotMatched = false;
        break;
      }

    }
    if (isNotMatched && arr2.length === arr1.length) {
      newArr.push(firstArray[i]);
      newArr.push(whenSameLegth);
    } else if (isNotMatched) {
      newArr.push(firstArray[i]);
    }
  }

  return newArr;
}

diffArray（[“安山岩”、“草地”、“泥土”、“粉红羊毛”、“死灌木”]、[“闪长岩”、“安山岩”、“草地”、“泥土”、“死灌木”]）

第二版适用于所有人

function diffArray(arr1, arr2) {
  var newArr = [];
  var firstArray = arr1;
  var secondArray = arr2;
  if (arr2.length > arr1.length) {
    firstArray = arr2;
    secondArray = arr1;
  }

  var whenSameLegth = '';
  var isNotMatched = false;

  for (var i in firstArray) {
    for (var j in secondArray) {
      if (firstArray[i] !== secondArray[j]) {
        isNotMatched = true;
        whenSameLegth = secondArray[j];
      } else {
        isNotMatched = false;
        break;
      }

    }
    if (isNotMatched && arr2.length === arr1.length) {
      newArr.push(firstArray[i]);
      newArr.push(whenSameLegth);
    } else if (isNotMatched) {
      newArr.push(firstArray[i]);
    }
  }

  return newArr;
}

diffArray（[“安山岩”、“草地”、“泥土”、“粉红羊毛”、“枯死灌木”]、[“闪长岩”、“安山岩”、“草地”、“泥土”、“枯死灌木”]）；
如果您可以使用最新版本的JavaScript（ES6），则以下操作应按线性时间运行，而不是按二次时间运行-O（N）与O（N²）


函数diffArray（a，b）{
a=新设置（a）
让结果=[]
for（b的let值）{
a、 删除（值）| |结果。推送（值）
}
结果。推送（…a）
返回结果
}
console.log（diffArray(
[1, 2, 3, 5],
[1, 2, 3, 4, 5]
))
console.log（diffArray(
[“闪长岩”、“安山岩”、“草地”、“泥土”、“粉红羊毛”、“死灌木”]，
[“闪长岩”、“安山岩”、“草”、“土”、“死灌木”]
))
如果您可以使用最新版本的JavaScript（ES6），那么下面的代码应该可以做到这一点，并以线性时间运行，而不是二次时间-O（N）与O（N²）


函数diffArray（a，b）{
a=新设置（a）
让结果=[]
for（b的let值）{
a、 删除（值）| |结果。推送（值）
}
结果。推送（…a）
返回结果
}
console.log（diffArray(
[1, 2, 3, 5],
[1, 2, 3, 4, 5]
))
console.log（diffArray(
[“闪长岩”、“安山岩”、“草地”、“泥土”、“粉红羊毛”、“死灌木”]，
[“闪长岩”、“安山岩”、“草”、“土”、“死灌木”]
))
您可以使用哈希表并计算发生次数。它也适用于数组中的多个Equala元素


函数getSymmetricDifference（a1，a2）{
var hash={}；
a1.forEach（功能（a）{
（hash[a]=hash[a]|{count:0，value:a}）；
});
a2.forEach（功能（a）{
（hash[a]=hash[a]|{count:0，value:a}）；
});
return Object.keys（hash）.filter（函数（a）{return hash[a].count；}）.map（函数（a）{return hash[a].value；}）；
}
log（getSymmetricDifference（[1,2,3,5]，[1,2,3,4,5]）；
console.log（getSymmetricDifference（[“闪长岩”、“安山岩”、“草”、“泥土”、“粉红羊毛”、“死灌木”]、[“闪长岩”、“安山岩”、“草”、“泥土”、“死灌木”]））；
您可以使用哈希表来计算发生率。它也适用于数组中的多个Equala元素


函数getSymmetricDifference（a1，a2）{
var hash={}；
a1.forEach（功能（a）{
（hash[a]=hash[a]|{count:0，value:a}）；
});
a2.forEach（功能（a）{
（hash[a]=hash[a]|{count:0，value:a}）；
});
return Object.keys（hash）.filter（函数（a）{return hash[a].count；}）.map（函数（a）{return