Fastest way to split object into smaller objects in Javascript?

I have a big object like below containing 1mil props.

{ 
"Name1":{"some":"object"},
"Name2":{"some":"object"},
"Name1000000":{"some":"object"}
}

I want to split this object into N parts so I wrote the following code

<!-- begin snippet: js hide: false console: true babel: false -->

<!-- language: lang-js -->

var bigObject = {
  "Name1": {
    "some": "object"
  },
  "Name2": {
    "some": "object"
  },
  "Name1000000": {
    "some": "object"
  }
};

const names = Object.keys(bigObject);
const partsCount = 4;
const parts = names
  .reduce((acc, name, idx) => {
    const reduceIndex = idx % partsCount;
    if (acc[reduceIndex] == null) {
      acc[reduceIndex] = {};
    }
    acc[reduceIndex][name] = request.body[name];
    return acc;
  }, new Array(Math.min(partsCount, names.length)));

<!-- end snippet -->

While this works, the problem is with performance. Currently it's taking 1.2 to 1.5 seconds!! Is there any performant way to write this code? My expectation is that this should be hardly double digit milliseconds for new processors running at ~3 GHz. Is my expectation wrong?

Update:
I somewhat don't understand why people are looking for solutions outside of the given problem/question by asking "why" and "what" you are doing with this code. some have assumed it to be database use case. There are literally 1000s of use cases, anyway mine is IOT sensor data ingestion where max of 1 million sensors data is aggregated into a bulk REST call which needs to be processed, now here comes second issue as soon as i reveal the use-case people will try to optimize that, so let me be clear i cannot change anything apart for the code shown above Its already a parsed object now i have to divide it and process it.

Testing if (acc[reduceIndex] == null) in every iteration seems inefficient, and since it sometimes accesses properties that don't exist, might considerably slow down your code. Try to pre-populate the array:

const parts = names.reduce((acc, name, idx) => {
  acc[idx % partsCount][name] = request.body[name];
  return acc;
}, Array.from({length: Math.min(partsCount, names.length)}, () => ({})));

But my approach here is to use Object.entries to divide the object into an array of its properties. Then divide those properties into N chunks using Array.slice, and then reassemble each chunk into an object using Object.fromEntries and finally push each object into an array of parts.

function partitionProperties(obj, partsCount) {
  const entries = Object.entries(obj);
  const parts = [];
  for (let i = 1, a = 0, b = 0; i <= partsCount; ++i) {
    a = b;
    b = i / partsCount * entries.length | 0;
    parts.push(Object.fromEntries(entries.slice(a, b)));
  }
  return parts;
}

It's important to acknowledge that, while this does divide the object into parts, it doesn't shuffle/arrange the properties into the same groups that you did. You shuffled/distributed them into groups one at a time like the way you would deal cards: [{a, d, g}, {b, e, h}, {c, f, i}] whereas this just partitions them [{a, b, c}, {d, e, f}, {g, h, i}]. But it's not clear that you were attached to the order or grouping.

I also don't know if this is the fastest, but it is relatively simple and straightforward, which has its own advantages.

I tried a lot of optimisation for the problem code right from sticking to one hidden class type in for v8 etc, profiling it i cannot take it down below 600ms
It seems Object.keys/Object.entries takes roughly 300ms, you can get some savings by pre-populating the parts array with 250000 props object but in total it was not under 100ms as i was originally thinking.

So i tried the array method as suggested in comments(change the bigObject to array of Objects) as code given below and i was able to split the whole thing in 73ms

Conclusion: Since i am not sure if i can change the original format to the new array format, but 1 thing is very clear stick to array in JS for any elements greater than 1K, I had my reasons to use object so that i don't get repeated prop names, but then its 73ms i guess merging them on server side would not be that bad i guess.

function main(names) {
    let parts = Array.from({ length: Math.min(partsCount, names.length) }, _ => []);
    for (let index = 0; index < names.length; index++) {
        parts[index % partsCount].push(names[index])
    }
    return parts;
}


const bigArray = Array.from({ length: 1000000 }, (_, idx) => ({ "tag": `Name${idx}`, "value": idx, "timestamp": date, "qualityh": idx, "qualityl": idx }));
const partsCount = 4;
console.time("B");
main(bigArray);
console.timeEnd("B");