How to Splice multiple elements (which don't follow consecutive order) in JavaScript?

user_8176451 0
Viewed 307

I have two arrays as follows:

array1: [c,d,e]    
array2: [[a,b,c,d,e], [1,2,3,4,5], [6,7,8,9,10]]

I have given an input which is [c,d,e].

What I want to achieve is remove all the corresponding index elements in array2 as shown below and only keep elements which have indices corresponding to [a,b] (In this case 0 and 1) and [c,d, e] needs to be removed, which is [3, 4, 5].

so the resultant output should be:

array2: [[a,b], [1,2], [6,7]]

Treat array2 as a table where 0th element is always going to be the header and rest all the data. Here it's not necessary that the array1 will have consecutive elements (like c,d and e) it can be (c, a, e) as well.

I was using:

x.forEach(elem => {
l.forEach(index => {
elem.splice(l,1);
})
})

But problem with this approach is that each time it slices out one element their relative position changes and hence gives out the wrong results. Any better and accurate way of doing so?

javascript
2 Answers

One possible approach:

function stripColumns(rowsWithHeader, columnsToStrip) {
  const header = rowsWithHeader[0];
  const indexesToStay = header.reduce((acc, col, i) => {
    if (!columnsToStrip.includes(col)) acc.push(i);
    return acc;
  }, []);
  return rowsWithHeader.map(row => indexesToStay.map(i => row[i]));
}

const inp = [['a','b','c','d','e'], [1,2,3,4,5], [6,7,8,9,10]];
const res = stripColumns(inp, ['c', 'd', 'e']);
console.log(res);

You can optimize this a bit, combining collecting indexes and filling out the first (header) row of the resulting array:

function stripColumns(rowsWithHeader, columnsToStrip) {
  const result = [[]], indexesToStay = [];

  const header = rowsWithHeader[0];
  header.forEach((col, i) => {
    if (columnsToStrip.includes(col)) {
       return;
    }
    indexesToStay.push(i);
    result[0].push(col);
  });

  for (let i = 1, len = rowsWithHeader.length; i < len; i++) {
    result[i] = indexesToStay.map(j => rowsWithHeader[i][j]);
  }

  return result;
}
const inp = [['a','b','c','d','e'], [1,2,3,4,5], [6,7,8,9,10]];
const res = stripColumns(inp, ['c', 'e']);
console.log(res);

... but I'm not really sure miniscule win in performance is worth increased complexity.

Note that for both approaches the original array stays intact; the function returns a new one. If that's not what you want, yes, you'll need to splice the elements in reverse order.

user_12290230

Mapping them to undefined or any safe value can make it easy to solve.

let filterArrays = (itemsToRemove, rows) => {
  const condition = rows[0].map(x => !itemsToRemove.includes(x))
  return rows.map(row => row.filter((item, index) => condition[index]))
}

let array1= ['c','d','e']    
let array2= [['a','b','c','d','e'], [1,2,3,4,5], [6,7,8,9,10]]

console.log(filterArrays(array1, array2))

user_21461250
Related