Komprimieren Objekthierarchien in JavaScript

Question

Gibt es einen generischen Ansatz zu verschachtelten Objekten auf einer Ebene „Komprimierung“:

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

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

Ich denke, es würde einige Rekursion beteiligt sein, aber ich dachte, ich muss nicht neu erfinden das Rad hier ...!?

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

Sie Mitglieder sind Mitglieder können geerbt von true in den zweiten Parameter.

ein paar Einschränkungen:

• rekursive Objekte nicht funktionieren. Zum Beispiel:

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

  wird rekursiv, bis es eine Ausnahme auslöst.

• Wie Ruquays Antwort zieht das Array-Elemente genau wie normale Objekteigenschaften heraus. Wenn Arrays intakt bleiben sollen, fügen Sie den Ausnahmen "|| prop instanceof Array" hinzu.

• Wenn Sie Objekte aus einem anderen Fenster oder Rahmen aufrufen, werden Datumsangaben und reguläre Ausdrücke nicht berücksichtigt, da instanceof nicht ordnungsgemäß funktioniert. Sie können das Problem beheben, indem es mit dem Standard-toString Methode wie folgt ersetzt:

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

Answer 2

Hier ist eine schnelle, aber aufgepasst, b/c wird es nicht arbeiten w/Arrays und Null-Werte (b/c ihre Typof gibt "Objekt" zurück).

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

Hier ist eine schnelle CoffeeScript Version basiert weg Matthew Crumley's answer (I nicht includePrototype verwendet haben, da ich keine Notwendigkeit, es hatte):

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 

und eine grundlegende Verflachung-Version, die mit wiederholten Separatoren und andere solche Verschlagenheit zweifellos scheitern würde:

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, ich verwende diese Funktionen, um Objektdiagramme in Redis hashes zu schieben, die nur eine einzelne Tiefe von Schlüssel/Wert-Paaren unterstützen.