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

The simplest way is as follows

getStates().map(x=>x.StateName).join(",")

Example is given below

function State(id,val,StateName) {
  this.id = id;
  this.val = val;
  this.StateName = StateName;
}

function getStates() {
 return [
  new State(1, 1, 'Arizona'),
  new State(2, 1, 'Alaska'),
  new State(3, 1, 'Florida'),
  new State(4, 1, 'Hawaii'),
  new State(5, 2, 'Gujarat'),
  new State(6, 2, 'Goa'),
  new State(7, 2, 'Punjab'),
  new State(8, 3, 'Queensland'),
  new State(9, 3, 'South Australia'),
  new State(10, 3, 'Tasmania'),
  new State(11, 4, 'Penang')
 ];
}

//Simplest Way is as follows
console.log(getStates().map(x=>x.StateName).join(","))

You can use

angular.toJson(array);

to create a json String of your array.

Edit:

var array = [{name: 'misko', dept: '007', city: 'new york' }, {name: 'misko', dept: '007',city: 'new york'}];

function createStringByArray(array) {
    var output = '';
    angular.forEach(array, function (object) {
        angular.forEach(object, function (value, key) {
            output += key + ',';
            output += value + ',';
        });
    });
    return output;
}

var string = createStringFromArray(array);

Basically you could just use:

var stringArray = [{id: 'svg', name: 'JASSI'}];
var objectArr = [];

stringArray.map(function(item) {
    objectArr.push(item.name);
});

console.log(objectArr);

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.

call a method that does the job. Something like this:

getSkills(element: any): string {
    let skills = "";

    element.skills.forEach(skill => {
        skills += skill.skill_name + ", ";
    }

    return skills;
}


<!--   skills Column-->
<ng-container matColumnDef="skills">
<th mat-header-cell *matHeaderCellDef> Skills </th>
<td mat-cell *matCellDef="let element"> {{getSkills(element)}} </td>
</ng-container>

let yourString = yourArray.map(e => e.replace(/\s/g, "")).join(",")

var test ="sai";
var array = [
  {'id':1,'description':test},
  {'id':2,'description':test},
  {'id':3,'description':test}
]

console.log(array.map(function(obj){return obj.id}))

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 do that in a single line like this:

this.users = this.users.map(user => user.name);

You could just run a simple conversion on it using the ConvertAll method in the Array class and a lambda on the object itself.

object[] inputArray = new object[10];
string[] resultArray = Array.ConvertAll(inputArray, x => x.ToString());

I've written the following on chrome console:

var foo = [
      {name: "foo1", information : "bar1" },
      {name: "foo2", information : "bar2" }
]
JSON.stringify(foo);

the output was: "[{"name":"foo1","information":"bar1"},{"name":"foo2","information":"bar2"}]"

I believe that is what you want.

This should do the job:

names: string[] = jsonObject.map(person => person.name); 

// => ["Bill Gates", "Max Payne", "Trump", "Obama"]

You can use the KeyValuePipe and you don't have to change anything in the object

export interface Isummary {
  toto: string[];
  foo: string[];
}

@Component({
  selector: "example",
  template: `
    <div *ngFor="let item of object | keyvalue">
      <span>key: {{ item.key }}</span>

      <span>Values</span>
      <span *ngFor="let value of item.value">{{ value }}</span>
    </div>
  `,
})
export class ExampleComponent {
  object: Isummary = {
    toto: ["titi", "tata"],
    foo: ["foobar", "footix"],
  };
}

or you can use Object.entries

@Component({
  selector: "example",
  template: `<div *ngFor="let item of object">
    <span>key: {{ item[0] }}</span>

    <span>Values</span>
    <span *ngFor="let value of item[1]">{{ value }}</span>
  </div>`,
})
export class ExampleComponent {
  object = Object.entries({
    toto: ["titi", "tata"],
    foo: ["foobar", "footix"],
  });
}

this.myHero = this.heroes[0].name; // display the name

Or if you want to keep your selected hero as an object then display the name in the template.

app.component.html

{{myHero.name}}

As for the array you need to loop over it and display something interesting on the object from the array itself.

<div *ngFor="#hero of heroes">
  {{hero.name}}
</div>

From your comment, here is your fixed code that displays the name of the myHero instance and from loop over the heros array.

<h1>{{title}}</h1>
<h2>My favorite hero is: {{myHero.name}}</h2>
<p>Heroes:</p>
<ul> <li *ngFor="let hero of heroes"> {{ hero.name }} </li> </ul>

or if You like to more functional code:

var arr = [];
angular.forEach(obj, function(value, key){
    arr.push(value);
});