compresión jerarquías de objetos de JavaScript

Question

¿Hay un enfoque genérico para "comprimir" objetos anidados a un solo nivel:

var myObj = { 
    a: "hello", 
    b: { 
     c: "world" 
    } 
} 

compress(myObj) == { 
    a: "hello", 
    b_c: "world" 
} 

supongo que habría algún recursividad involucrados, pero pensé que no necesito reinventar la rueda aquí ...!?

Answer 1

function flatten(obj, includePrototype, into, prefix) { 
    into = into || {}; 
    prefix = prefix || ""; 

    for (var k in obj) { 
     if (includePrototype || obj.hasOwnProperty(k)) { 
      var prop = obj[k]; 
      if (prop && typeof prop === "object" && 
       !(prop instanceof Date || prop instanceof RegExp)) { 
       flatten(prop, includePrototype, into, prefix + k + "_"); 
      } 
      else { 
       into[prefix + k] = prop; 
      } 
     } 
    } 

    return into; 
} 

Puede incluir miembros heredados miembros pasando true en el segundo parámetro.

algunas advertencias:

• objetos recursivos no funcionará. Por ejemplo:

  var o = { a: "foo" }; 
  o.b = o; 
  flatten(o); 
  

  se repetirán hasta que arroje una excepción.

• Al igual que la respuesta de ruquay, esto extrae los elementos de la matriz al igual que las propiedades normales del objeto. Si desea mantener las matrices intactas, agregue "|| prop instanceof Array" a las excepciones.

• Si llama esto a objetos de una ventana o marco diferente, las fechas y las expresiones regulares no se incluirán, ya que instanceof no funcionarán correctamente. Se puede arreglar eso sustituyéndolo por el método toString por defecto de esta manera:

  Object.prototype.toString.call(prop) === "[object Date]" 
  Object.prototype.toString.call(prop) === "[object RegExp]" 
  Object.prototype.toString.call(prop) === "[object Array]" 
  

Answer 2

He aquí uno rápido, pero ojo, b/c no funciona con matrices y valores nulos (b/c su typeof devuelve "objeto").

var flatten = function(obj, prefix) { 
    if(typeof prefix === "undefined") { 
    prefix = ""; 
    } 
    var copy = {}; 
    for (var p in obj) { 
    if(obj.hasOwnProperty(p)) { 
     if(typeof obj[p] === "object") { 
     var tmp = flatten(obj[p], p + "_"); 
     for(var q in tmp) { 
      if(tmp.hasOwnProperty(q)) { 
      copy[prefix + q] = tmp[q]; 
      } 
     } 
     } 
     else { 
     copy[prefix + p] = obj[p]; 
     } 
    } 
    } 
    return copy; 
} 

var myObj = { 
    a: "level 1", 
    b: { 
    a: "level 2", 
    b: { 
     a: "level 3", 
     b: "level 3" 
    } 
    } 
} 

var flattened = flatten(myObj); 

Answer 3

Aquí está basada una versión rápida CoffeeScript fuera Matthew Crumley's answer (yo no uso includePrototype ya que no tenía necesidad de él):

flatten = (obj, into = {}, prefix = '', sep = '_') -> 
    for own key, prop of obj 
    if typeof prop is 'object' and prop not instanceof Date and prop not instanceof RegExp 
     flatten prop, into, prefix + key + sep, sep 
    else 
     into[prefix + key] = prop 
    into 

y una versión básica unflatten, lo que sin duda fallar con repetidos separadores y otros tales astucia:

unflatten = (obj, into = {}, sep = '_') -> 
    for own key, prop of obj 
    subKeys = key.split sep 
    sub = into 
    sub = (sub[subKey] or= {}) for subKey in subKeys[...-1] 
    sub[subKeys.pop()] = prop 
    into 

FWIW, utilizo estas funciones para insertar gráficos de objetos en Redis hashes, que solo admiten una profundidad única de pares clave/valor.