You need to push a newly created item to your array like below:

CoinArray.push(new Coin.Create('123)); 

On the other hand if you want to create an object with keys ids and values corresponding Coin objects, you should try this:

CoinDictionary = {};
CoinDictionary['123'] = new Coin.Create('123');

Note:

I think that you should refactor a bit the Coin if you want to use it as a constructor function:

function Coin(id){
    this.id = id;
}

Doing this change you can use it as below:

CoinArray.push(new Coin('123'));

function Coin(id){
    this.id = id;
}

var CoinArray = [];
CoinArray.push(new Coin('123'));
CoinArray.push(new Coin('456'));
CoinArray.push(new Coin('789'));

console.log(CoinArray);

Update

At the end I want to have array with object and for example I will take first el of array, and execute other method from Coin class.

For this purpose If I were you I would have gone with the creation of an object with keys the ids and values references to Coin objects:

function Coin(id){
    this.id = id;
}

Coin.prototype.start = function(){
    console.log("game with id "+this.id+" started.");
}

Coins = {}
Coins['123'] = new Coin('123');
Coins['456'] = new Coin('456');
Coins['789'] = new Coin('789');

Coins['456'].start();

You can use the array filter or find methods

ArrPerson.find(p=>p.name=='john')
ArrPerson.filter(p=>p.name=='john')

The find method searches the array from the beginning and stops when it finds one element that matches. In the worst case where the element that is being searched is the last in the array or it is not present this method will do O(n).This means that this method will do n checks (n as the length of the array) until it stops.

The filter method always does O(n) because every time it will search the whole array to find every element that matches.

Although you can make something much more faster(in theory) by creating a new data stucture.Example:

var hashmap = new Map();
var ArrPerson = [];
ArrPerson.push(new Person("john",12,"M1"));
hashmap.set("john",true);

This ES6 Map will keep an index of the whole array based on the names it contains. And if you want to see if your array contains a name you can do:

hashmap.has('john')//true

This approach will do O(1). It will only check once on the map to see if this name exists in your array. Also, you can track the array indexes inside the map:

var index = ArrPerson.push(new Person("john",12,"M1"));
var map_indexes = hashmap.get("john");
if(map_indexes){
  map_indexes.push(index-1);
  hashmap.set("john",map_indexes);
}else{
  hashmap.set("john",[index-1]);
}
map_indexes = hashmap.get("john"); //an array containing the ArrPerson indexes of the people named john
//ArrPerson[map_indexes[0]] => a person named john
//ArrPerson[map_indexes[1]] => another person named john ...

With this approach not only you can tell if there is a person in the array with the specific name but you can also find the whole object with O(1). Take into account that this map will only index people by name if you want other criteria you need another map. Also keeping two data structures synchronized is not easy(deleting one element from array should also be deleted from the map, etc)

In conclusion, as always increasing speed ends sacrificing something else, memory and code complexity in our example.

You can use Array.prototype.reduce function, like this

console.log(data.reduce(function(result, current) {
    var obj = {};
    result[current.id_0] = result[current.id_0] || [];
    obj[current.id_1] = current.name_1;
    result[current.id_0].push(obj);
    return result
}, {}));

Output

{ '356': [ { '33': 'aaaa' }, { '27': 'dddd' } ],
  '456': [ { '89': 'ccccc' } ],
  '756': [ { '89': 'bbbbb' } ] }

If you want to convert this to an array of object, just wrap the result of data.reduce with [] like this

console.log([data.reduce(function(result, current) {
    ...
    ...
}, {})]);

Edit:

result[current.id_0] = result[current.id_0] || [];

this line makes sure that result[current.id_0] is an array. If the value of result[current.id_0] is truthy, then that value is rturned but if it is not, then [] will be returned. So, a new array will be created and assigned to result[current.id_0]. It is actually a shorthand for

if (result.hasOwnProperty(current.id_0) === false) {
    result[current.id_0] = [];
}

Edit 2: If you like to keep the grouped elements as an object, you could do like this

console.log(data.reduce(function(result, current) {
    result[current.id_0] = result[current.id_0] || {};
    result[current.id_0][current.id_1] = current.name_1;
    return result
}, {}));

Output

{ '356': { '27': 'dddd', '33': 'aaaa' },
  '456': { '89': 'ccccc' },
  '756': { '89': 'bbbbb' } }

You can use the Array.prototype.map method of an array.

Simply call a map over the array, get the data in order from the array item and return the object you want in the map function.

const arr = [
  ["Benni", 24, "Whatever"],
  ["Paul", 23, "Whatever"]
];

const remapped = arr.map((data) => {
  const [name, age, Text] = data;
  return {
    name,
    age,
    Text,
  };
});

console.log(remapped);

I would propose this solution based on a dynamic number of keys:

var arr = test.map(function(obj){
    return Object.keys(obj). // convert object to array of keys
         reduce(function(arr, current){arr.push(obj[current]); return arr}, []); // generate a new array based on object values 
});

Use Object.assign for this so that you can combine the array with the common id value, use find having condition that compares the id of both the objects.

var data1 =[ {foo:'2',box:'yes',id:'1234'},{foo:'34',box:'no',id:'1235'} ]; 
var data2 =[{key:'value',key2:'value2', id:'1234'},{key:'value',key2:'value2', id:'1235'}];

data1.map(x => Object.assign(x, data2.find(y => y.id == x.id)));

console.log(data1);

Since you have same key name multiple times which is ignored by the JSON object so I have taken a new property name key2 for this example.