使用 javascript array.reduce 删除重复项

Question

我是 javascript 的新手，我在从网络教程中自己学习它时遇到了一些挑战。 请帮我解决下面的问题。

问题：

编写一个函数，该函数接受两个或多个数组，并按照原始提供的数组的顺序返回一个包含唯一值的新数组。

换句话说，所有数组中存在的所有值都应按其原始顺序包含在内，但在最终数组中没有重复项。

唯一数字应按其原始顺序排序，但最终数组不应按数字顺序排序。

只使用 Array.reduce 来解决这个问题！ 您的解决方案应该如下所示：

function unite(arr1, arr2, arr3) {
  return arr1;
}

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

我无法理解如何在此处使用 reduce。 与此相比，所有互联网示例都非常简单。 https://www.airpair.com/javascript/javascript-array-reduce http://adripofjavascript.com/blog/drips/boiling-down-arrays-with-array-reduce.html

我的错误解决方案：

function arrayDiff(resultArray, element){
    var idx = anotherArray.indexOf(element);
    if(idx != -1){
        resultArray.push(element);
        return resultArray;
    }
}

function unite(arr1, arr2, arr3) {
    var arr = [];
    var r1 = arr1.reduce(arrayDiff);
    var r2 = arr2.reduce(arrayDiff);
    var r3 = arr3.reduce(arrayDiff);
    arr.concat(r1).concat(r2).concat(r3);
    return arr;
}


r = unite([1, 2, 3], [5, 2, 1, 4], [2, 1]);
console.log(r);

错误：ReferenceError：anotherArray 未定义

Answer 1

要处理多个数组参数，您可以使用arguments 。 多亏了这一点，你的函数可以接受N 个参数，它更通用。

然后，您可以展平所有数组参数，并开始减少数据。 当您减少我们的数组时，您将通过排除冗余数据来创建一个新数组。 因此，您将从一个空数组开始，然后通过 reduce 过程填充它。

  function unite(){
    //Flat array arguments, then process to reduce data
    return [].concat.apply([], arguments).reduce(function(result, current){
      //If my result array doesn't get current element
      return result.indexOf(current) === -1
      //concat current element to result and return it
      ? result.concat(current)
      //Otherwise, just return actual result array
      : result;
    }, []);
  }

  var array = unite([1,2], [1,6,2,3], [4,5]);

  console.log(array);
  //[1,2,6,3,4,5]

编辑 06/02/2017：

现在，您可以使用扩展运算符来处理多个参数，例如通过解构赋值。 此外，我们可以通过将indexOf()操作与按位运算符~一起使用来提高性能。

function unite(...data) {
  return [].concat.apply([], data).reduce((result, current) => {
    return ~result.indexOf(current)
    ? result
    : result.concat(current)
  }, []);
}

console.log(unite([1,2,3], [1, 4, 4, 5, 6]));

Answer 2

我想你想检查element是否已经在resultArray ，而不是在一些anotherArray 。 有了这个，它可能有点工作：

function arrayDiff(resultArray, element){
    var idx = resultArray.indexOf(element);
    if (idx == -1) { // add only when not already found in the result array
        resultArray.push(element);
    }
    return resultArray; // always return the resultArray even if we didn't add to it
}

function unite(arr1, arr2, arr3) {
    var r0 = [];
    var r1 = arr1.reduce(arrayDiff, r0); // supply some start accumulator argument
    var r2 = arr2.reduce(arrayDiff, r1); // and pass the results through so that
    var r3 = arr3.reduce(arrayDiff, r2); // duplicates are filtered amongst all arrays
    return r3;
}

Answer 3

这是我的解决方案，更干净/更短：

function uniteUnique(arr) {
  var args = Array.from(arguments);
  var test = [];

  for ( var i = 0; i < args.length; i++ ) {
    for (var j = 0; j < args[i].length; j++ ) {
      if ( test.indexOf(args[i][j]) == -1 ) {      
          test.push(args[i][j]);
      }
    }
  }

  return test;
}

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

Answer 4

我的解决方案

function unique(array) {
  return array.reduce(function(results,currentItem){ 
    //using array include
    return results.includes(currentItem)? results: [...results,currentItem];

    //using array find
    //return results.find(function(result){return currentItem===result})?results:[...results,currentItem];
  },[]);
}