Seems like a great idea.
I often find myself using objects when I’m building data (like a horrible CSV processor). It’s easy to pull in a row of data, and potentially modify existing data (yeh, really horrible CSV).

But when it gets to processing the data (transformers and database), I prefer arrays.

A lot of it comes back to typescript, where Object.keys().forEach means the key isn’t necessarily usable to access the item in the object (the whole, a key becomes a string, but an object can be keyed by string/number/symbol). .
So, whatever you come up with HAS to have first class Typescript support.

If you’re not married to functional code, for searching a keyed object by property for the key, you can always write:

for (const key in data) {
  if (data[key].firstName === 'Frederic') {
    console.log(key);
  }
}

No need to transform the whole object with Object.entries, and you could turn that into a function reasonably easy, something like findKey(object, property, value) or some such.

Shouldnt you be asking this on StackOverflow? I am here to read programming news…

If you have IDs I’d use a Map.

Have you considered storing as a Map instead?

MDN Map docs

I just found two packages that do the same thing as I did :

• indexed-array
• keyed-array

The last one comes with a blog post explaining the same things I did !

I’m pretty sure I’ve been in your situation but haven’t created a dictionary/array hybrid.

Without any more details about your use case and situation, I can imagine a few pitfalls with your solution:

• Serialization might not behave as you would expect (JSON.stringify).
• 3rd-party functions might not be able to deal with your data structure properly (again, potentially unexpected behavior).
• You can’t easily access array methods (find, filter, map etc).
• How do you distinguish between ID access and index access? ArrayLike([ {id: "1" }, { id: "2" } ])[1] returns { id: "2" }, how do you access { id: "1" } by ID?
• It’s harder to reason about access time of lookups. However, this might not be a concern of yours.
• It may cause confusion if you’re working with other developers.

That being said, unless you work in an environment where your code should be easily understandable by others, the best way to find out if this is a good idea or not, is to try :)

Me personally, I usually use an associateBy function, when I need a values-by-ID structure. Of course this is not as convenient to use as your approach, but it’s good enough for me.

// this WILL drop elements if key is not unique 
function associateBy(array, key) {
  return array.reduce((acc, el) => ({
    ...acc,
    [el[key]]: el
  }), {});
}

associateBy([
  {id: "foo"},
  {id: "bar"}
], "id").foo; // -> {id: "foo"}

Good luck!