Node.js destructuring vs proxy for object combinations

index.js

const Benchmark = require('benchmark');
const suite = new Benchmark.Suite;

function createObject(start, end, smallData) {
  let obj = {};
  for (let cur = start; cur < end; cur++) {
    obj['prop' + cur] = 'value' + cur;
  }
  return obj;
}

const objA = createObject(0, 10);
const objB = createObject(9, 19);

function cached(func) {
  let func2 = () => {
    return {
      result: func()
    };
  };
  let value;
  return () => {
    return (value || (value = func2())).result;
  }
};

function combineProxy(objA, objB) {
  let getKeys = cached(() => new Set([...Object.keys(objA), ...Object.keys(objB)]));
  let getKeysArray = cached(() => [...getKeys()]);
  return new Proxy({}, {
    has (target, key) {
      return getKeys().has(key);
    },
    get (target, key) {
      return objA[key] || objB[key];
    },
    set (target, key, value) {
      return false;
    },
    deleteProperty (target, property) {
      return false;
    },
    ownKeys (target) {
      return getKeysArray().slice();
    },
    apply (target, thisArg, args) {
      throw new TypeError('Proxy cannot be called');
    },
    construct (target, thisArg, args) {
      throw new TypeError('Proxy cannot be constructed');
    }
  });

}

suite.add('Proxy', function () {
  return combineProxy(objA, objB);
}).add('Destructuring', function () {
  return {
    ...objA,
    ...objB
  };
}).on('cycle', event => console.log(String(event.target)))
.on('complete', function () {
  console.log('Fastest is ' + this.filter('fastest').map('name'));
})
.run({'async': false});