如何使用相同的键匹配和合并两个对象数组

Question

Given the following Arrays of Objects:

old = [{x:1, y:100}, {x:2, y:5}, {x:3, y:400}] 
update = [{x:1, y:5}, {x:3, y:0}]

old should be updated: if x old matches x update: y old should be updated,

if y of update is 0, the object of x old should be removed from the old array.

My approach

let merge = (update, old) => {
  for(let I of update) {
    let K = old.findIndex(J => J.x== I.x)

    (K === -1 && I.y != 0) && old.push(I)

    (K >= 0) && (old[K] = I) && ((old[K].y== 0) && old.splice(K,1))

  }
}

Any experts in using map filter reduce or spread operator? What is the best to do here? Is there a shortcut method (syntax sugar)?

Answer 1

If performance matters an interesting question is if the two arrays are sorted. If yes you can just loop through both the same way a merge in merge sort works and do it in O(n) instead of O(n^2).

If you have no duplicates of x I would consider using Set s instead of arrays.

To transform the array to a set you can do:

const map = arr.reduce((m, v) => m.set(m.x, m.y), new Map());

a Map will likely have a better performance when using get then a array when using find (which at best is O(n log n).

Now if you have a guarantee, that every element in the new array is also in the old array its easy:

new Map([...oldMap.entries(), ...newMap.entries()]);

this is because Map takes an array of two-element array where the first is the key and the second is the value. And if you pass a key twice the second will win, so thats your overwriting.

Now if you dont want maps but your original structure the entire thing with converting back and forth could look like this:

function merge(update, old) {
  const toMap = arr => arr.map(e => [e.x, e.y]);
  return new Map([...toMap(old), ...toMap(update)])
    .entries()
    .map(([x, y]) => ({ x, y }));
}

Answer 2

You need to specify more contingencies. What do we do for the object at old[2], since update.length is only 2? Also, your condition:

"if y of update is 0, the object of x old should be removed from the old array"

is a bit unclear. Try using dot-notation if possible, as this is probably better understood by everyone here.

Anyways, here's my take, though it's possibly I misunderstood the conditions that need to be satisfied. I assumed that a value at old[index] when index >= update.length should just be returned as-is.

const result = old.map( ( value, index ) => {
    if ( update[index] ){
        if ( update[index].y === 0 ) return null
        if ( value.x === update[index].x ) {
            return {
                x: value.x,
                y: update[index].y
            }
        }
    }
    return value
} ).filter( value => value )

This yeilds the following output:

[
  { x: 1, y: 5 },
  { x: 3, y: 400 }
]