Run results for: True object merge comparison

Test name	Executions per second
Using Reduce ES5	3650722.5 Ops/sec
Using Reduce ES5 (test with `in`)	3501851.0 Ops/sec
Using Reduce ES5 (test with `hasOwnProperty`)	3520715.5 Ops/sec
Using Reduce ES6	2175248.8 Ops/sec
Using Reduce ES6 (test with `in`)	2121035.5 Ops/sec
Using Reduce ES6 (test with `hasOwnProperty`)	2144708.0 Ops/sec
Using For...	6637014.0 Ops/sec
Using For... (test with `in`)	6695592.5 Ops/sec
Using For... (test with `hasOwnProperty`)	6725904.5 Ops/sec
Using For... In	17939292.0 Ops/sec
Using For... In (test with `in`)	18357428.0 Ops/sec
Using For... In (test with `hasOwnProperty`)	18217462.0 Ops/sec

Using Reduce ES5

const firstObject = {
  a: 'Hello,',
  b: 'World'
};

const secondObject = { b: 'World!', c: '!' };

const mergedObject = Object.keys(firstObject)
  .reduce(function(accumulator, key) {
    let toMerge = secondObject[key];
    
    if (!toMerge) {
      toMerge = firstObject[key];
    }
    
    accumulator[key] = toMerge;
    return accumulator;
  }, {});

Using Reduce ES5 (test with `in`)

const firstObject = {
  a: 'Hello,',
  b: 'World'
};

const secondObject = { b: 'World!', c: '!' };

const mergedObject = Object.keys(firstObject)
  .reduce(function(accumulator, key) {
    accumulator[key] = firstObject[key];
    
    if (key in secondObject) {
      accumulator[key] = secondObject[key];
    }
    
    return accumulator;
  }, {});

Using Reduce ES5 (test with `hasOwnProperty`)

const firstObject = {
  a: 'Hello,',
  b: 'World'
};

const secondObject = { b: 'World!', c: '!' };

const mergedObject = Object.keys(firstObject)
  .reduce(function(accumulator, key) {
    accumulator[key] = firstObject[key];
    
    if (secondObject.hasOwnProperty(key)) {
      accumulator[key] = secondObject[key];
    }
    
    return accumulator;
  }, {});

Using Reduce ES6

const firstObject = {
  a: 'Hello,',
  b: 'World'
};

const secondObject = { b: 'World!', c: '!' };

const mergedObject = Object.keys(firstObject)
  .reduce((a, key) => {
    let toMerge = secondObject[key];
    
    if (!toMerge) {
      toMerge = firstObject[key];
    }
    
    return { ...a, [key]: toMerge};
  }, {});

Using Reduce ES6 (test with `in`)

const firstObject = {
  a: 'Hello,',
  b: 'World'
};

const secondObject = { b: 'World!', c: '!' };

const mergedObject = Object.keys(firstObject)
  .reduce((a, key) => {
    let toMerge = firstObject[key];
    
    if (key in secondObject) {
      toMerge = secondObject[key];
    }
    
    return { ...a, [key]: toMerge};
  }, {});

Using Reduce ES6 (test with `hasOwnProperty`)

const firstObject = {
  a: 'Hello,',
  b: 'World'
};

const secondObject = { b: 'World!', c: '!' };

const mergedObject = Object.keys(firstObject)
  .reduce((a, key) => {
    let toMerge = firstObject[key];
    
    if (secondObject.hasOwnProperty(key)) {
      toMerge = secondObject[key];
    }
    
    return { ...a, [key]: toMerge};
  }, {});

Using For...

const firstObject = {
  a: 'Hello,',
  b: 'World'
};

const secondObject = { b: 'World!', c: '!' };

let mergedObject = firstObject;
const keys = Object.keys(mergedObject);

for (let index = 0; index < keys.length; index++) {
	const key = keys[index];
  
    if (secondObject[key]) {
      mergedObject[key] = secondObject[key];
    }    
}

Using For... (test with `in`)

const firstObject = {
  a: 'Hello,',
  b: 'World'
};

const secondObject = { b: 'World!', c: '!' };

let mergedObject = firstObject;
const keys = Object.keys(mergedObject);

for (let index = 0; index < keys.length; index++) {
	const key = keys[index];
  
    if (key in secondObject) {
      mergedObject[key] = secondObject[key];
    }    
}

Using For... (test with `hasOwnProperty`)

const firstObject = {
  a: 'Hello,',
  b: 'World'
};

const secondObject = { b: 'World!', c: '!' };

let mergedObject = firstObject;
const keys = Object.keys(mergedObject);

for (let index = 0; index < keys.length; index++) {
	const key = keys[index];
  
    if (secondObject.hasOwnProperty(key)) {
      mergedObject[key] = secondObject[key];
    }    
}

Using For... In

const firstObject = {
  a: 'Hello,',
  b: 'World'
};

const secondObject = { b: 'World!', c: '!' };

let mergedObject = firstObject;

for (let key in mergedObject) {
  if (secondObject[key]) {
    mergedObject[key] = secondObject[key];
  }
}

Using For... In (test with `in`)

const firstObject = {
  a: 'Hello,',
  b: 'World'
};

const secondObject = { b: 'World!', c: '!' };

let mergedObject = firstObject;

for (let key in mergedObject) {
  if (key in secondObject) {
    mergedObject[key] = secondObject[key];
  }
}

Using For... In (test with `hasOwnProperty`)

const firstObject = {
  a: 'Hello,',
  b: 'World'
};

const secondObject = { b: 'World!', c: '!' };

let mergedObject = firstObject;

for (let key in mergedObject) {
  if (secondObject.hasOwnProperty(key)) {
    mergedObject[key] = secondObject[key];
  }
}