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：

现在，您可以使用spread operator来处理多个参数，例如通过解构分配。此外，我们可以通过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];
  },[]);
}

使用javascript array.reduce删除重复项

4 个答案: