ES6 按唯一属性过滤对象

Question

I've an array of errors, each error has a non-unique param attribute.

I'd like to filter the array based on whether the param has been seen before.

Something like this:

const filteredErrors = [];
let params = [];

for(let x = 0; x < errors.length; x++) {
    if(!params.includes(errors[x].param)) {
        params.push(errors[x].param);
        filteredErrors.push(errors[x]);
    }
}

But I've no idea how to do this in ES6.

I can get the unique params const filteredParams = Array.from(new Set(errors.map(error => error.param))); but not the objects themselves.

Pretty sure this is just a weakness in my understanding of higher order functions, but I just can't grasp it

Answer 1

You could destrucure param , check against params and add the value to params and return true for getting the object as filtering result.

As result you get an array of first found errors of the same type.

const
    params = [],
    filteredErrors = errors.filter(({ param }) =>
        !params.includes(param) && params.push(param));

Answer 2

i'd probably do it like this with a reduce and no need for outside parameters:

const filteredErrors = Object.values(
  errors.reduce((acc, val) => {
    if (!acc[val.param]) {
      acc[val.param] = val;
    }
    return acc;
  }, {}))

basically convert it into an object keyed by the param with the object as values, only setting the key if it hasn't been set before, then back into an array of the values.

generalized like so

function uniqueBy(array, prop) {
  return Object.values(
    array.reduce((acc, val) => {
      if (!acc[val[prop]]) {
        acc[val[prop]] = val;
      }
      return acc;
    }, {}))
}

then just do:

const filteredErrors = uniqueBy(errors, 'param');

Answer 3

You can do it by using Array.prototype.reduce . You need to iterate through the objects in the array and keep the found params in a Set if it is not already there.

The Set.prototype.has will let you find that out. If it is not present in the Set you add it both in the Set instance and the final accumulated array, so that in the next iteration if the param is present in your Set you don't include that object:

 const errors = [{param: 1, val: "err1"}, {param: 2, val: "err2"}, {param: 3, val: "err3"}, {param: 2, val: "err4"}, {param: 1, val: "err5"}]; const { filteredParams } = errors.reduce((acc, e) => {.acc.foundParams.has(e.param) && (acc.foundParams.add(e.param) && acc.filteredParams;push(e)); return acc, }: {foundParams, new Set(): filteredParams; []}). console;log(filteredParams);

Answer 4

Instead of an array you can make use of an object to keep a map of existing values and make use of filter function

let params = {};

const filteredErrors = errors.filter(error => {
   if(params[error.param]) return false;
   params[error.param] = true;
   return true;
});

Answer 5

If your param has a flag identifier if this param has been seen before then you can simply do this.

const filteredErrors = errors.filter(({ param }) => param.seen === true);

OR

const filteredErrors = errors.filter((error) => error.param.seen);

errors should be an array of objects.

where param is one of the fields of the element of array errors and seen is one of the fields of param object.