Vfrdtyky

If you are looking for a functional approach:

var obj = {1: 11, 2: 22};

var arr = Object.keys(obj).map(function (key) { return obj[key]; });

Results in:

[11, 22]

The same with an ES6 arrow function:

Object.keys(obj).map(key => obj[key])

With ES7 you will be able to use Object.values instead (more information):

var arr = Object.values(obj);

Or if you are already using Underscore/Lo-Dash:

var arr = _.values(obj)

I think you can use for in but checking if the property is not inerithed

myObj= {1:[Array-Data], 2:[Array-Data]}

var arr =;

for( var i in myObj ) {

    if (myObj.hasOwnProperty(i)){

       arr.push(myObj[i]);

    }

}

EDIT - if you want you could also keep the indexes of your object, but you have to check if they are numeric (and you get undefined values for missing indexes:

function isNumber(n) {

  return !isNaN(parseFloat(n)) && isFinite(n);

}



myObj= {1:[1,2], 2:[3,4]}

var arr =;

for( var i in myObj ) {

    if (myObj.hasOwnProperty(i)){

        if (isNumber(i)){

            arr[i] = myObj[i];

        }else{

          arr.push(myObj[i]);

        }

    }

}

Simply do

Object.values(obj);

That's all!

If you know the maximum index in you object you can do the following:

var myObj = {

    1: ['c', 'd'],

    2: ['a', 'b']

  },

  myArr;



myObj.length = 3; //max index + 1

myArr = Array.prototype.slice.apply(myObj);

console.log(myArr); //[undefined, ['c', 'd'], ['a', 'b']]

Since ES5 Object.keys() returns an array containing the properties defined directly on an object (excluding properties defined in the prototype chain):

Object.keys(yourObject).map(function(key){ return yourObject[key] });

ES6 takes it one step further with arrow functions:

Object.keys(yourObject).map(key => yourObject[key]);

Nowadays, there is a simple way to do this : Object.values().

var myObj = {

    1: [1, 2, 3],

    2: [4, 5, 6]

};



console.log(Object.values(myObj));

Output:

[[1, 2, 3], [4, 5, 6]]

This doesn't required jQuery, it's been defined in ECMAScript 2017.

It's supported by every modern browser (forget IE).

x = ;

for( var i in myObj ) {

    x[i] = myObj[i];

}

The best method would be using a javascript -only function:

var myArr = Array.prototype.slice.call(myObj, 0);

ECMASCRIPT 5:

Object.keys(myObj).map(function(x) { return myObj[x]; })

ECMASCRIPT 2015 or ES6:

Object.keys(myObj).map(x => myObj[x])

How about jQuery.makeArray(obj)

This is how I did it in my app.

The solving is very simple

var my_obj = {1:[Array-Data], 2:[Array-Data]}

Object.keys(my_obj).map(function(property_name){ 

    return my_obj[property_name]; 

});

Fiddle Demo

Extension to answer of bjornd .

var myObj = {

    1: [1, [2], 3],

    2: [4, 5, [6]]

}, count = 0,

    i;

//count the JavaScript object length supporting IE < 9 also

for (i in myObj) {

    if (myObj.hasOwnProperty(i)) {

        count++;

    }

}

//count = Object.keys(myObj).length;// but not support IE < 9

myObj.length = count + 1; //max index + 1

myArr = Array.prototype.slice.apply(myObj);

console.log(myArr);

Array.prototype.slice()

Function.prototype.apply()

Object.prototype.hasOwnProperty()

Object.keys()

If you want to keep the name of the object's properties as values. Example:

var fields = {

    Name: { type: 'string', maxLength: 50 },

    Age: { type: 'number', minValue: 0 }

}

Use Object.keys(), Array.map() and Object.assign():

var columns = Object.keys( fields ).map( p => Object.assign( fields[p], {field:p} ) )

Result:

[ { field: 'Name', type: 'string', maxLength: 50 }, 

  { field: 'Age', type: 'number', minValue: 0 } ]

Explanation:

Object.keys() enumerates all the properties of the source ; .map() applies the => function to each property and returns an Array ; Object.assign() merges name and value for each property.

I made a custom function:

    Object.prototype.toArray=function(){

    var arr=new Array();

    for( var i in this ) {

        if (this.hasOwnProperty(i)){

            arr.push(this[i]);

        }

    }

    return arr;

};

After some tests, here is a general object to array function convertor:

You have the object:

var obj = {

    some_key_1: "some_value_1"

    some_key_2: "some_value_2"

};

The function:

function ObjectToArray(o)

{

    var k = Object.getOwnPropertyNames(o);

    var v = Object.values(o);



    var c = function(l)

    {

        this.k = ;

        this.v = ;

        this.length = l;

    };



    var r = new c(k.length);



    for (var i = 0; i < k.length; i++)

    {

        r.k[i] = k[i];

        r.v[i] = v[i];

    }



    return r;

}

Function Use:

var arr = ObjectToArray(obj);

You Get:

arr {

    key: [

        "some_key_1",

        "some_key_2"

    ],

    value: [

        "some_value_1",

        "some_value_2"

    ],

    length: 2

}

So then you can reach all keys & values like:

for (var i = 0; i < arr.length; i++)

{

    console.log(arr.key[i] + " = " + arr.value[i]);

}

Result in console:

some_key_1 = some_value_1

some_key_2 = some_value_2

Edit:

Or in prototype form:

Object.prototype.objectToArray = function()

{

    if (

        typeof this != 'object' ||

        typeof this.length != "undefined"

    ) {

        return false;

    }



    var k = Object.getOwnPropertyNames(this);

    var v = Object.values(this);



    var c = function(l)

    {

        this.k = ;

        this.v = ;

        this.length = l;

    };



    var r = new c(k.length);



    for (var i = 0; i < k.length; i++)

    {

        r.k[i] = k[i];

        r.v[i] = v[i];

    }



    return r;

};

And then use like:

console.log(obj.objectToArray);

You can create a simple function to do the conversion from object to array, something like this can do the job for you using pure javascript:

var objectToArray = function(obj) {

  var arr = ;

  if ('object' !== typeof obj || 'undefined' === typeof obj || Array.isArray(obj)) {

    return obj;

  } else {

    Object.keys(obj).map(x=>arr.push(obj[x]));

  }

  return arr;

};

or this one:

var objectToArray = function(obj) {

  var arr =;

  for(let o in obj) {

    if (obj.hasOwnProperty(o)) {

      arr.push(obj[o]);

    }

  }

  return arr;

};

and call and use the function as below:

var obj = {1:'a', 2:'b', 3:'c', 4:'d', 5:'e'};

objectToArray(obj); // return ["a", "b", "c", "d", "e"]

Also in the future we will have something called Object.values(obj), similar to Object.keys(obj) which will return all properties for you as an array, but not supported in many browsers yet...

ES8 way made easy:

The official documentation

    const obj = { x: 'xxx', y: 1 };

    let arr = Object.values(obj); // ['xxx', 1]

    console.log(arr);