Appiattisci oggetto su matrice?

Question

Sto usando un oggetto come tabella hash. Mi piacerebbe stampare rapidamente i suoi contenuti (per alert() per esempio). C'è qualcosa di integrato per convertire un hash in matrici di coppie (chiave, valore)?

Answer 1

ho aggiornato questo un po 'di più. Questo è molto più semplice da analizzare rispetto a console.log perché lascia fuori le cose extra che sono lì come __proto__.

function flatten(obj) { 
    var empty = true; 
    if (obj instanceof Array) { 
     str = '['; 
     empty = true; 
     for (var i=0;i<obj.length;i++) { 
      empty = false; 
      str += flatten(obj[i])+', '; 
     } 
     return (empty?str:str.slice(0,-2))+']'; 
    } else if (obj instanceof Object) { 
     str = '{'; 
     empty = true; 
     for (i in obj) { 
      empty = false; 
      str += i+'->'+flatten(obj[i])+', '; 
     } 
     return (empty?str:str.slice(0,-2))+'}'; 
    } else { 
     return obj; // not an obj, don't stringify me 
    } 
} 

L'unica cosa che vorrei fare per migliorare questo è l'hanno rientrare correttamente in base al livello di ricorsione.

Answer 2

Utilizzare il ciclo for:

for (var x in yourObj) 
{ 
    alert(yourObj[x]); 
} 

Answer 3

Non che io sappia. Ancora, si può fare da soli piuttosto conciso:

var obj = { a: 1, b: 2, c: 3 }; 
var arr = []; 
for (var i in obj) { 
    var e = {}; 
    e[i] = obj[i]; 
    arr.push(e); 
} 
console.log(arr); 
// Output: [Object { a=1 }, Object { b=2 }, Object { c=3 }] 

Naturalmente, non si può alert questa operazione, così si potrebbe anche semplicemente console.log(obj) in primo luogo.

---

È potrebbe array di uscita di array:

var obj = { a: 1, b: 2, c: 3 }; 
var arr = []; 
for (var i in obj) { 
    arr.push([i, obj[i]]); 
} 
console.log(arr); 
// Output: [["a", 1], ["b", 2], ["c", 3]] 

alert(arr); 
// Alert: a, 1, b, 2, c, 3 

Ma, ancora una volta, ew.

Answer 4

Dal momento che si desidera alert presumo che non è per la versione di produzione, e che la vecchia compatibilità del browser non è un problema.

Se questo è il caso, allora si può fare questo:

var myHash = ...... 
alert(Object.keys(myHash).map(function(key) { return [key, myHash[key]]; })); 

Answer 5

per un rapido utilizzo & sporco in alert si potrebbe usare JSON:

alert(JSON.stringify(yourObj).replace(/,/g,'\n')); 

Answer 6

Qui è la mia versione di esso. Esso dovrebbe consentire di appiattire ingresso come di seguito:

var input = { 
    a: 'asdf', 
    b: [1,2,3], 
    c: [[1,2],[3,4]], 
    d: {subA: [1,2]} 
} 

La funzione è simile a questo:

function flatten (input, output) { 

     if (isArray(input)) { 
     for(var index = 0, length = input.length; index < length; index++){ 
      flatten(input[index], output); 
     } 
     } 
     else if (isObject(input)) { 
     for(var item in input){ 
      if(input.hasOwnProperty(item)){ 
      flatten(input[item], output); 
      } 
     } 
     } 
     else { 
     return output.push(input); 
     } 
    }; 

    function isArray(obj) { 
     return Array.isArray(obj) || obj.toString() === '[object Array]'; 
    } 

    function isObject(obj) { 
     return obj === Object(obj); 
    } 

Usage è qualcosa di simile:

uscita var = []

appiattire (input Output);

Quindi l'output deve essere l'array appiattito.

Answer 7

Forse un po 'in ritardo, ma qui avete la mia versione della risposta, aggiornata a ES2015. Io uso una funzione ricorsiva e funziona anche se ci sono altri oggetti all'interno dell'oggetto principale:

function objectFlattener (object) { 
    return Reflect.apply(Array.prototype.concat, [], Object.keys(object).map(key => { 
    if (object[key] instanceof Object) { 
     return objectFlattener(object[key]); 
    } 
    return `${ key }: ${ object[key] }`; 
    })); 
} 

Così modificato l'ultima di ritorno è possibile formattare l'elemento all'interno dell'array.