Comment puis-je aplatir et déaplatir efficacement les objets JavaScript imbriqués ?

Aplatir et déaplatir des objets JavaScript imbriqués

Aplatir et déaplatir des objets JavaScript imbriqués peut être une tâche essentielle dans de nombreuses applications. Cependant, cela peut s’avérer une opération complexe et coûteuse en termes de calcul. Dans cet article, nous explorerons deux approches pour aplatir et déaplatir les objets imbriqués qui peuvent améliorer considérablement les performances.

Aplatissement et déaplatissement efficaces

La première approche, proposée par Bergi , se concentre sur l'utilisation d'une expression régulière pour analyser les clés d'objet et naviguer efficacement dans la structure de l'objet. Voici le code de la fonction d'aplatissement :

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

Pour la fonction d'aplatissement, il est recommandé d'omettre les vérifications "isEmpty" pour améliorer les performances :

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- Approche Regex

La deuxième approche, proposée par Bergi et modifiée par AaditMShah, évite d'utiliser des expressions régulières et s'appuie uniquement sur des opérations de chaîne pour analyser les clés d'objet. Cette approche est particulièrement efficace lorsque les clés d'objet suivent certaines conventions de dénomination.

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

Résultats de performances

Les benchmarks fournis montrent que ces approches peuvent améliorer considérablement les performances d'aplatissement et de déaplatissement des objets imbriqués, offrant une augmentation de vitesse substantielle par rapport au code d'origine. Ces techniques sont particulièrement utiles dans les scénarios où des objets volumineux et complexes doivent être traités efficacement.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!