尝试使用 Javascript 解决对称差异

我正在尝试找出对称的解决方案 使用 javascript 完成以下任务的差异 目标：

• 接受未指定数量的数组作为参数
• 保留数组中数字的原始顺序
• 不删除单个数组中数字的重复项
• 删除数组中出现的重复项

因此，例如， 如果输入是 ([1, 1, 2, 6], [2, 3, 5], [2, 3, 4])， 解为 [1, 1, 6, 5, 4]。

我正在尝试解决这个问题，这是网上提出的挑战 编码社区。挑战的具体说明 状态，

创建一个接受两个或多个数组并返回一个数组的函数 所提供数组的对称差。

数学术语对称差指的是元素 属于第一组或第二组但不属于两者的两组。

虽然我下面的解决方案找到了数字 每个数组都是唯一的，它消除了所有出现的数字 超过一次并且不保持数字的顺序。

我的问题与以下问题非常接近在javascript中查找多个数组中的对称差异/唯一元素 https://stackoverflow.com/questions/30468692/finding-symmetric-difference-unique-elements-in-multiple-arrays-in-javascript。然而，解决方案 不保留数字的原始顺序，也不保留单个数组中出现的唯一数字的重复项。

function sym(args){
    var arr = [];
    var result = [];
    var units;
    var index = {};
    for(var i in arguments){
        units = arguments[i];

    for(var j = 0; j < units.length; j++){
         arr.push(units[j]);
        }
    }

    arr.forEach(function(a){
        if(!index[a]){
            index[a] = 0;
        }
            index[a]++;

    });

       for(var l in index){
           if(index[l] === 1){
               result.push(+l);
           }
       }

    return result;
}
symsym([1, 1, 2, 6], [2, 3, 5], [2, 3, 4]); // => Desired answer: [1, 1, 6. 5. 4]

与所有问题一样，最好从编写算法开始：

数组的串联版本，其中每个数组都经过过滤以包含除当前数组之外的任何数组所包含的元素

然后用 JS 写下来：

function sym() {
  var arrays = [].slice.apply(arguments);

  return [].concat.apply([],               // concatenate
    arrays.map(                            // versions of the arrays
      function(array, i) {                 // where each array
        return array.filter(               // is filtered to contain
          function(elt) {                  // those elements which
            return !arrays.some(           // no array
              function(a, j) {             // 
                return i !== j             // other than the current one
                  && a.indexOf(elt) >= 0   // contains
                ;
              }
            );
          }
        );
      }
    )
  );
}

无注释版本，使用 ES6 编写更简洁：

function sym(...arrays) {
  return [].concat(arrays . 
    map((array, i) => array . 
      filter(elt => !arrays . 
        some((a, j) => i !== j && a.indexOf(elt) >= 0))));
}