Convert Array to Object Convert Array to Object arrays arrays

Convert Array to Object


ECMAScript 6 introduces the easily polyfillable Object.assign:

The Object.assign() method is used to copy the values of allenumerable own properties from one or more source objects to a targetobject. It will return the target object.

Object.assign({}, ['a','b','c']); // {0:"a", 1:"b", 2:"c"}

The own length property of the array is not copied because it isn't enumerable.

Also, you can use ES8 spread syntax on objects to achieve the same result:

{ ...['a', 'b', 'c'] }

For custom keys you can use reduce:

['a', 'b', 'c'].reduce((a, v) => ({ ...a, [v]: v}), {}) // { a: "a", b: "b", c: "c" }


With a function like this:

function toObject(arr) {  var rv = {};  for (var i = 0; i < arr.length; ++i)    rv[i] = arr[i];  return rv;}

Your array already is more-or-less just an object, but arrays do have some "interesting" and special behavior with respect to integer-named properties. The above will give you a plain object.

edit oh also you might want to account for "holes" in the array:

function toObject(arr) {  var rv = {};  for (var i = 0; i < arr.length; ++i)    if (arr[i] !== undefined) rv[i] = arr[i];  return rv;}

In modern JavaScript runtimes, you can use the .reduce() method:

var obj = arr.reduce(function(acc, cur, i) {  acc[i] = cur;  return acc;}, {});

That one also avoids "holes" in the array, because that's how .reduce() works.


You could use an accumulator aka reduce.

['a','b','c'].reduce(function(result, item, index, array) {  result[index] = item; //a, b, c  return result;}, {}) //watch out the empty {}, which is passed as "result"

Pass an empty object {} as a starting point; then "augment" that object incrementally.At the end of the iterations, result will be {"0": "a", "1": "b", "2": "c"}

If your array is a set of key-value pair objects:

[{ a: 1},{ b: 2},{ c: 3}].reduce(function(result, item) {  var key = Object.keys(item)[0]; //first property: a, b, c  result[key] = item[key];  return result;}, {});

will produce: {a: 1, b: 2, c: 3}

For the sake of completeness, reduceRight allows you to iterate over your array in reverse order:

[{ a: 1},{ b: 2},{ c: 3}].reduceRight(/* same implementation as above */)

will produce: {c:3, b:2, a:1}

Your accumulator can be of any type for you specific purpose. For example in order to swap the key and value of your object in an array, pass []:

[{ a: 1},{ b: 2},{ c: 3}].reduce(function(result, item, index) {  var key = Object.keys(item)[0]; //first property: a, b, c  var value = item[key];  var obj = {};  obj[value] = key;  result.push(obj);  return result;}, []); //an empty array

will produce: [{1: "a"}, {2: "b"}, {3: "c"}]

Unlike map, reduce may not be used as a 1-1 mapping. You have full control over the items you want to include or exclude. Therefore reduce allows you to achieve what filter does, which makes reduce very versatile:

[{ a: 1},{ b: 2},{ c: 3}].reduce(function(result, item, index) {  if(index !== 0) { //skip the first item    result.push(item);  }  return result;}, []); //an empty array

will produce: [{2: "b"}, {3: "c"}]

Caution: reduce and Object.key are part of ECMA 5th edition; you should provide a polyfill for browsers that don't support them (notably IE8).

See a default implementation by Mozilla.