Convert array of strings into an array of objects

Question

I have this JavaScript array:

[ "124857202", "500255104", "78573M104" ]

I want to convert this particular array into an array of objects as shown below:

[
  { name: "124857202" },
  { name: "500255104" },
  { name: "78573M104" }
]

Answer 1

Use Array#map to convert each value into a different value:

var newArr = arr.map(function(value) {
  return {name: value};
});

Array#map applies the callback to each element in the array and returns a new array containing the return values of the callback.

Answer 2

I would take a look at the array.map function in javascript.

const mappedArr = arr.map(value => {
  return {
    name: value
  }
})

Answer 3

Another approach - Array#reduce .

 var arr = ["124857202", "500255104", "78573M104"]; var res = arr.reduce(function(s, a){ s.push({name: a}); return s; }, []) console.log(res);

Answer 4

I want to convert this particular array into an array of objects as shown below

If you want to change the actual array in place (rather than creating a new array), you can use a for loop to iterate the indexes of your array. For each index, you can replace the value with an object {name: arr[i]} . This object has a name key, and takes a value which is the current element arr[i] .

 const arr = [ "124857202", "500255104", "78573M104" ]; for(let i = 0; i < arr.length; i++) { arr[i] = {name: arr[i]}; } console.log(arr);

Or, if you want to make a new array and leave the original untouched, you can use Felix's answer , here it can be re-written to use more modern ES6 features to make it more concise, such as an arrow function and shorthand property names :

 const arr = [ "124857202", "500255104", "78573M104" ]; const res = arr.map(name => ({name})); console.log(res);

Answer 5

You can use

var arrayOfStrings = ["124857202", "500255104", "78573M104"];
var arrayOfObjects = [];

arrayOfStrings.forEach(function (element, index) {
   arrayOfObjects.push({
        name: element,
   })
});

Answer 6

Felix Kling' answer , gehsekky's answer and the second part of Nick Parsons' answer are the most correct. For completeness, here is a version that uses Underscore's _.map :

import { map } from 'underscore';
var result = map(array, name => ({name}));

For this particular use case, _.map doesn't buy you much compared to Array.prototype.map except for a little bit of added portability. Going the other way, however, is a bit easier on the brain with _.map because of Underscore's iteratee shorthands:

// Underscore map
var array = map(result, 'name');

// Array.prototype.map
var array = result.map(obj => obj.name);

Underscore's map and other collection functions really shine when you need to iterate over a plain object, since JavaScript's built-in methods don't support this at all:

var objectOfStrings = {
    first: "124857202",
    second: "500255104",
    third: "78573M104"
};

// to array of strings, Underscore
var arrayOfStrings = map(objectOfStrings);

// to array of strings, vanilla JS
var arrayOfStrings = [], value;
for (key in objectOfStrings) {
    arrayOfStrings.push(objectOfStrings[key]);
}

// to array of objects, Underscore
var arrayOfObjects = map(objectOfStrings, name => ({name}));

// to array of objects, vanilla JS
var arrayOfStrings = [], name;
for (key in objectOfStrings) {
    name = objectOfStrings[key];
    arrayOfStrings.push({name});
}

var objectOfObjects = {
    first: {name: "124857202"},
    second: {name: "500255104"},
    third: {name: "78573M104"}
};

// to array of strings, Underscore
var arrayOfStrings = map(objectOfStrings, 'name');

// to array of strings, vanilla JS
var arrayOfStrings = [], value;
for (key in objectOfObjects) {
    arrayOfStrings.push(objectOfObjects[key].name);
}

// to array of objects, Underscore
var arrayOfObjects = map(objectOfObjects);

// to array of objects, vanilla JS
var arrayOfObjects = [], value;
for (key in objectOfStrings) {
    arrayOfObjects.push(objectOfStrings[key]);
}