Wie kann ich verschachtelte JavaScript-Objekte effizient reduzieren und wieder entfernen?

Verschachtelte JavaScript-Objekte reduzieren und entglätten

Verschachtelte JavaScript-Objekte verflachen und entglätten kann in vielen Anwendungen eine wesentliche Aufgabe sein. Allerdings kann es sich um einen komplexen und rechenintensiven Vorgang handeln. In diesem Artikel werden wir zwei Ansätze zum Reduzieren und Aufheben der Glättung verschachtelter Objekte untersuchen, die die Leistung erheblich verbessern können.

Effizientes Glätten und Aufheben der Glättung

Der erste Ansatz, vorgeschlagen von Bergi konzentriert sich auf die Verwendung eines regulären Ausdrucks zum Parsen der Objektschlüssel und zum effizienten Navigieren in der Objektstruktur. Hier ist der Code für die Unflattening-Funktion:

Object.unflatten = function(data) {
    "use strict";
    if (Object(data) !== data || Array.isArray(data))
        return data;
    var regex = /\.?([^.\[\]]+)|\[(\d+)\]/g,
        resultholder = {};
    for (var p in data) {
        var cur = resultholder,
            prop = "",
            m;
        while (m = regex.exec(p)) {
            cur = cur[prop] || (cur[prop] = (m[2] ? [] : {}));
            prop = m[2] || m[1];
        }
        cur[prop] = data[p];
    }
    return resultholder[""] || resultholder;
};

Für die Flattening-Funktion wird empfohlen, die „isEmpty“-Prüfungen wegzulassen, um die Leistung zu verbessern:

Object.flatten = function(data) {
    var result = {};
    function recurse (cur, prop) {
        if (Object(cur) !== cur) {
            result[prop] = cur;
        } else if (Array.isArray(cur)) {
             for(var i=0, l=cur.length; i<l; i++)
                 recurse(cur[i], prop + "[" + i + "]");
        } else {
            for (var p in cur) {
                recurse(cur[p], prop ? prop+"."+p : p);
            }
        }
    }
    recurse(data, "");
    return result;
}

Non- Regex-Ansatz

Der zweite Ansatz, vorgeschlagen von Bergi und weiter modifiziert von AaditMShah vermeidet die Verwendung regulärer Ausdrücke und verlässt sich ausschließlich auf Zeichenfolgenoperationen, um die Objektschlüssel zu analysieren. Dieser Ansatz ist besonders effizient, wenn die Objektschlüssel bestimmten Namenskonventionen folgen.

Object.unflatten = function(data) {
    "use strict";
  if (Object(data) !== data || Array.isArray(data)) return data;
  var result = {};
  for (var key in data) {
    var parts = key.split('.'),
      cur = result;
    for (var i = 0; i < parts.length; i++) {
      if (!cur[parts[i]]) {
        cur[parts[i]] = (i == parts.length - 1) ? data[key] : {};
      }
      cur = cur[parts[i]];
    }
  }
  return result[""] || result;
};

Object.flatten = function(data) {
  var result = {};
  function recurse(cur, prop) {
    if (Object(cur) !== cur) {
      result[prop] = cur;
    } else if (Array.isArray(cur)) {
      for (var i = 0; i < cur.length; i++)
        recurse(cur[i], prop + "[" + i + "]");
    } else {
      var isEmpty = true;
      for (var p in cur) {
        isEmpty = false;
        recurse(cur[p], prop ? prop + "." + p : p);
      }
      if (isEmpty) result[prop] = {};
    }
  }
  recurse(data, "");
  return result;
};

Leistungsergebnisse

Die bereitgestellten Benchmarks zeigen, dass diese Ansätze deutlich verbessert werden können die Leistung beim Reduzieren und Aufheben der Glättung verschachtelter Objekte, was eine erhebliche Geschwindigkeitssteigerung im Vergleich zum Originalcode bietet. Diese Techniken sind besonders nützlich in Szenarien, in denen große und komplexe Objekte effizient verarbeitet werden müssen.

Das obige ist der detaillierte Inhalt vonWie kann ich verschachtelte JavaScript-Objekte effizient reduzieren und wieder entfernen?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!