If your array of objects is items, you can do:

var items = [{
  id: 1,
  name: 'john'
}, {
  id: 2,
  name: 'jane'
}, {
  id: 2000,
  name: 'zack'
}];

var names = items.map(function(item) {
  return item['name'];
});

console.log(names);
console.log(items);

Documentation: map()

You can use .map() for this. It passes the index into the callback.

myArray = myArray.map((str, index) => ({ value: str, id: index + 1 }));

You can use Array.prototype.map for that:

var arr = [
  {"text":"demo1"},
  {"text":"demo2"}
];
var texts = arr.map(function(el) {
  return el.text;
});
console.log(texts);

And with ES6, you can use arrow functions:

var texts = arr.map((el) => el.text);

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.

Check out this jsfiddle. You'll see both Array.prototype.reduce and Array.prototype.map used, both with the same results.

This is classic reduce:

var people = person.reduce(function(agg, p) {
  return agg.concat([p.name + p.age + p.address]);
}, []);

The above uses Array.prototype.reduce.

In other words, when you want all the properties of an object or array "reduced" into something, then the most semantic go-to option is probably Array.prototype.reduce in this case.

However, Array.prototype.map can also do the job quite cleanly:

var people = person.map(function(p) {
  return p.name + p.age + p.address;
});

This is an argument, now, between readability/complexity vs. semantics.

To limit incidental complexity (in the form of readability), I might go for the map function, even though you could argue this is technically a paradigmatic reduction.

You need to return a result from the mapper function.

let myNewArray = myArray.map( str => {
      let obj = {};
      obj['Id'] = '111' ;
      obj['Value'] = str ;
      return obj;
});
// or 
let myNewArray = myArray.map( str =>  ({Id:111,Value:str}) );
// parenthesis are needed to remove the ambiguity with `{}`
console.log(myNewArray);

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map#Using_map_to_reformat_objects_in_an_array

You can use Array.map

let newArray = arr.map(a => Object.values(a))

If you cant use Object.values

let newArray = arr.map(a => Object.keys(a).map(k => a[k]))

Output

(2) [Array(4), Array(4)]
    0:(4) ["AAA", "bbbb", "CCCC", "ddddd"]
    1:(4) ["lmn", "opq", "rst", "uvw"]