Conversione di un object JS in un array usando jQuery

La mia applicazione crea un object JavaScript, come il seguente:

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

Ma ho bisogno di questo object come una matrice.

 array[1]:[Array-Data] array[2]:[Array-Data] 

Così ho provato a convertire questo object in un array iterando con $.each attraverso l’object e aggiungendo l’elemento a un array:

 x=[] $.each(myObj, function(i,n) { x.push(n);}); 

C’è un modo migliore per convertire un object in un array o forse una funzione?

 var myObj = { 1: [1, 2, 3], 2: [4, 5, 6] }; var array = $.map(myObj, function(value, index) { return [value]; }); console.log(array); 

Produzione:

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

Se stai cercando un approccio funzionale:

 var obj = {1: 11, 2: 22}; var arr = Object.keys(obj).map(function (key) { return obj[key]; }); 

Risultati in:

 [11, 22] 

Lo stesso con una funzione freccia ES6:

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

Con ES7 potrai utilizzare Object.values ( ulteriori informazioni ):

 var arr = Object.values(obj); 

O se stai già utilizzando Underscore / Lo-Dash:

 var arr = _.values(obj) 

Penso che tu possa usare for in ma controllando se la proprietà non è stata riallatta

 myObj= {1:[Array-Data], 2:[Array-Data]} var arr =[]; for( var i in myObj ) { if (myObj.hasOwnProperty(i)){ arr.push(myObj[i]); } } 

MODIFICA: se lo desideri, puoi anche conservare gli indici del tuo object, ma devi controllare se sono numerici (e ottieni valori indefiniti per gli indici mancanti:

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

Semplicemente

 Object.values(obj); 

È tutto!

Se conosci l’indice massimo nel tuo object, puoi fare quanto segue:

 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']] 

Poiché ES5 Object.keys () restituisce una matrice contenente le proprietà definite direttamente su un object (escluse le proprietà definite nella catena del prototipo):

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

ES6 compie un ulteriore passo avanti con le funzioni freccia:

 Object.keys(yourObject).map(key => yourObject[key]); 
 x = []; for( var i in myObj ) { x[i] = myObj[i]; } 

Il metodo migliore sarebbe utilizzare una funzione javascript-only:

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

ECMASCRIPT 5:

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

ECMASCRIPT 2015 o ES6:

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

Che ne dici di jQuery.makeArray(obj)

Questo è come l’ho fatto nella mia app.

Al giorno d’oggi, c’è un modo semplice per farlo: Object.values ​​() .

 var myObj = { 1: [1, 2, 3], 2: [4, 5, 6] }; console.log(Object.values(myObj)); 

Produzione:

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

Questo non richiede jQuery, è stato definito in ECMAScript 2017.
È supportato da tutti i browser moderni (dimentica IE).

La soluzione è molto semplice

 var my_obj = {1:[Array-Data], 2:[Array-Data]} Object.keys(my_obj).map(function(property_name){ return my_obj[property_name]; }); 

Fiddle Demo

Estensione a risposta di 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); 

Riferimento

Array.prototype.slice ()

Function.prototype.apply ()

Object.prototype.hasOwnProperty ()

Object.keys ()

Se si desidera mantenere il nome delle proprietà dell’object come valori. Esempio:

 var fields = { Name: { type: 'string', maxLength: 50 }, Age: { type: 'number', minValue: 0 } } 

Usa Object.keys() , Array.map() e Object.assign() :

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

Risultato:

 [ { field: 'Name', type: 'string', maxLength: 50 }, { field: 'Age', type: 'number', minValue: 0 } ] 

Spiegazione:

Object.keys() enumera tutte le proprietà del codice sorgente; .map() applica la funzione => a ciascuna proprietà e restituisce una matrice; Object.assign() unisce nome e valore per ogni proprietà.

Ho creato una funzione personalizzata:

  Object.prototype.toArray=function(){ var arr=new Array(); for( var i in this ) { if (this.hasOwnProperty(i)){ arr.push(this[i]); } } return arr; }; 

Dopo alcuni test, ecco un object generale al convertitore di funzioni di array:

Hai l’object:

 var obj = { some_key_1: "some_value_1" some_key_2: "some_value_2" }; 

La funzione:

 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++) { rk[i] = k[i]; rv[i] = v[i]; } return r; } 

Funzione uso:

 var arr = ObjectToArray(obj); 

Ottieni:

 arr { key: [ "some_key_1", "some_key_2" ], value: [ "some_value_1", "some_value_2" ], length: 2 } 

Quindi puoi raggiungere tutte le chiavi e i valori come:

 for (var i = 0; i < arr.length; i++) { console.log(arr.key[i] + " = " + arr.value[i]); } 

Risultato in console:

 some_key_1 = some_value_1 some_key_2 = some_value_2 

Modificare:

O in forma di prototipo:

 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++) { rk[i] = k[i]; rv[i] = v[i]; } return r; }; 

E quindi utilizzare come:

 console.log(obj.objectToArray); 

Puoi creare una semplice funzione per fare la conversione da un object all’altro, qualcosa del genere può fare il lavoro per te usando il javascript puro:

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

o questo:

 var objectToArray = function(obj) { var arr =[]; for(let o in obj) { if (obj.hasOwnProperty(o)) { arr.push(obj[o]); } } return arr; }; 

e chiama e usa la funzione come di seguito:

 var obj = {1:'a', 2:'b', 3:'c', 4:'d', 5:'e'}; objectToArray(obj); // return ["a", "b", "c", "d", "e"] 

Anche in futuro avremo qualcosa chiamato Object.values(obj) , simile a Object.keys(obj) che restituirà tutte le proprietà come array, ma non ancora supportato in molti browser …