Convert array of strings into an array of objects

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.

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

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

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);

You can use

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

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

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]);
}