Bagaimanakah Saya Boleh Meratakan dan Meratakan Objek JavaScript Bersarang dengan Cekap?

Meratakan dan Tidak Meratakan Objek JavaScript Bersarang

Meratakan dan tidak meratakan objek JavaScript bersarang boleh menjadi tugas penting dalam banyak aplikasi. Walau bagaimanapun, ia boleh menjadi operasi yang rumit dan mahal dari segi pengiraan. Dalam artikel ini, kami akan meneroka dua pendekatan untuk meratakan dan tidak meratakan objek bersarang yang boleh meningkatkan prestasi dengan ketara.

Meratakan dan Tidak Merata yang Cekap

Pendekatan pertama, yang dicadangkan oleh Bergi , memfokuskan pada menggunakan ungkapan biasa untuk menghuraikan kekunci objek dan menavigasi struktur objek dengan cekap. Berikut ialah kod untuk fungsi tidak mendatar:

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

Untuk fungsi merata, adalah disyorkan untuk meninggalkan semakan "isEmpty" untuk meningkatkan prestasi:

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

Bukan- Pendekatan Regex

Pendekatan kedua, dicadangkan oleh Bergi dan diubahsuai lagi oleh AaditMShah, mengelak daripada menggunakan ungkapan biasa dan bergantung semata-mata pada operasi rentetan untuk menghuraikan kekunci objek. Pendekatan ini amat berkesan apabila kekunci objek mengikut konvensyen penamaan tertentu.

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

Hasil Prestasi

Tanda aras yang disediakan menunjukkan bahawa pendekatan ini boleh meningkatkan dengan ketara prestasi meratakan dan tidak meratakan objek bersarang, menawarkan peningkatan kelajuan yang ketara berbanding kod asal. Teknik ini amat berfaedah dalam senario di mana objek besar dan kompleks perlu diproses dengan cekap.

Atas ialah kandungan terperinci Bagaimanakah Saya Boleh Meratakan dan Meratakan Objek JavaScript Bersarang dengan Cekap?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!