Javascript Array to Object How to convert an array into an object in javascript

This is good, anyhow is an antipattern, it should be something like:

const convertArrayToObject = (array, key) => 
  array.reduce((acc, curr) => {
    acc[curr[key]] = curr;
    return acc;
  }, {});

// Even concise
const convertArrayToObject = (array, key) => 
  array.reduce((acc, curr) =>(acc[curr[key]] = curr, acc), {});
// Basically everything inside parentheses will be evaluated, only the last value used will be only returned.

In this way, you avoid the spread op which is a way expensive than a single assignment

Nice!

I had to write one of these the other day.

Here's a slightly more concise version, where you throw out extra brackets and use an implicit return 😄 :

const convertArrayToObject = (array, key) =>
  array.reduce(
    (obj, item) => ({
      ...obj,
      [item[key]]: item
    }),
    {}
  );

the [item[key]] tripped me up initially haha.

So long as you don't have to support older browsers, or are using Babel, new ES features do this without the need of a helper function. See the MDN docs for Object.fromEntires.

I faced out with this problem and I took as a reference: stackoverflow.com/a/44325124

And I created some similar that your solution but with less lines and more faster

const convertArrayToObject = (array, key) => 
   array.reduce((obj, item) => ((obj[[item[key]]] = item), obj), {});

I have another example to wotk with your Code, but I didn't reach it.

My Array:

[
{"name":"Product 1","series":{"name":"Area 1","value":3}},
{"name":"Product 2","series":{"name":"Area 2","value":3}},
{"name":"Product 1","series":{"name":"Area 2","value":1}},
]

Need to convert it to an object like this:

[ {"name": "Product 1",
"series":[{"name":"Area 1","value":3},{"name":"Area 2","value":1}] },
{"name":"Product 2",
"series":[{"name":"Area 2","value":3}] }
];

It would be nice if you could give my any advice how to reach this by adopting your Code?

I know that this post is from 2019, but I guess I will offer some more recent way of writing this:

const convert = (array, keyName) => Object.fromEntries(
  array.map(item => [item[keyName], item])
);

Or if you want to remove the key from the object:

const convert = (array, keyName) => Object.fromEntries(
  array.map(({ [keyName]: key, ...item }) => [key, item])
);

Thank you, this was very handy.
I remixed it a little:

const convertArrayToObject = (array) => {
    return _.reduce(array, (accumulator, currentValue) => {
        accumulator = Object.assign(accumulator, currentValue);
        return accumulator;
    }, {});
};

Here's type-friendly version in TypeScript

export function convertArrayToObject
<
T extends { [prop in string | number]: any },
K extends keyof Pick<T, {
    [Key in keyof T]: T[Key] extends string | number ? Key : never
}[keyof T]> = keyof Pick<T, {
    [Key in keyof T]: T[Key] extends string | number ? Key : never
}[keyof T]>,
A extends T[] = T[]
>
(array: readonly T[], key: K)
{
    const initialValue = {};
    return array.reduce((obj, item) => {
        return {
            ...obj,
            [item[key]]: item,
        };
    }, initialValue) as { [propkey in A[number][K]]: A[number]; };
}

Notes:
• TypeScript 4.0+ (tested on 4.0.x and 4.1.x)

• for the 2nd arg TS will allow and suggest only those keys for which all objects hold a value of type number or string (only those types by which any object props can be indexed).
So if all those objects had a prop BD with a string value for all the people, except John's BD was a Date object, TS won't suggest nor allow you to choose 'BD' for the 2nd arg.

• that single usage of any here is intentional. As a result, it's going to be collapsed, whereas using unknown would require several additional checks.

• usage of as operator to assert the type of return value is intentional. May be unnecessary in future TypeScript versions.

• works perfectly for variable data, but only almost perfect for constant data.
Here in this example if you denote that test array as const, TS will be able to tell you that the object has 5 properties 111, 112, 122, 123, 125, but won't be able to tell you which object exactly under each key and think its a union type of all objects for each key.
So, given the passed array had as const annotation and the returned object from the example is called fooobj:

const bar = fooobj[111];
// it thinks bar is of type of one of the objects from the original array

const name = bar.name;
// TS suggests name is of type 'John' | 'Sarah' | 'Kate' | 'Tom' | 'Emma'

if (bar.id === 111){
    // only here types collapse, asserting the exact value for bar props
    const name = bar.name;
    // TS is convinced that name === 'John'
}

What about Object.fromEntries()?

const convertArrayToObject = (arr,propName) => Object.fromEntries(arr.map(({[propName]:prop,...rest}) => [prop, {...rest}]));

can someone help how to get this output

a = [{id: 1, value: 1}, {id: 1, value: 2},
{id: 2, value: 20}, {id: 3, value: 30}]

output-->

{1: [{id: 1, value: 1}, {id: 1, value: 2}],
2: [{id: 2, value: 20}],3:[{id: 3, value: 30}]}