JSON数据多维度结构化优化咨询：避免冗余与双向查询

Great question—this is a super common pain point when working with JSON for bidirectional queries. Let’s break down a few practical, low-maintenance solutions that avoid redundancy and manual updates:

1. Separate Reverse Index Mapping (Best for Large Datasets) #

Instead of duplicating your actual data, create a lightweight reverse index that only tracks which parent keys map to each child key. This keeps your source data single-sourced while enabling fast bidirectional lookups.

Example Structure: #

{
  "sourceData": {
    "AAA": { 
      "1": { "value": "Sample Data 1" }, 
      "2": { "value": "Sample Data 2" }, 
      "3": { "value": "Sample Data 3" } 
    },
    "BBB": { 
      "1": { "value": "Sample Data 1" }, 
      "3": { "value": "Sample Data 3" }, 
      "4": { "value": "Sample Data 4" } 
    },
    "CCC": { 
      "1": { "value": "Sample Data 1" }, 
      "3": { "value": "Sample Data 2" } 
    }
  },
  "reverseIndex": {
    "1": ["AAA", "BBB", "CCC"],
    "2": ["AAA"],
    "3": ["AAA", "BBB", "CCC"],
    "4": ["BBB"]
  }
}

How to Maintain It: #

Wrap your data updates (add/remove parent-child pairs) in simple helper functions that automatically sync the index. For example (in JavaScript):

function addChildToParent(parentKey, childKey, childData, store) {
  // Update source data
  if (!store.sourceData[parentKey]) store.sourceData[parentKey] = {};
  store.sourceData[parentKey][childKey] = childData;
  
  // Update reverse index
  if (!store.reverseIndex[childKey]) store.reverseIndex[childKey] = [];
  if (!store.reverseIndex[childKey].includes(parentKey)) {
    store.reverseIndex[childKey].push(parentKey);
  }
}

This way, you never have to manually edit the index—all syncing happens behind the scenes. Queries are lightning fast:

• Get child data for a parent: store.sourceData['AAA']['2']
• Get parents for a child: store.reverseIndex['1']

2. Dynamic Query Functions (Best for Small Datasets) #

If your dataset isn’t huge, skip storing an index entirely and generate parent-child associations on the fly with a simple function. This eliminates any maintenance overhead.

Example Function (JavaScript): #

function getParentKeysForChild(childKey, sourceData) {
  return Object.keys(sourceData).filter(parentKey => {
    return sourceData[parentKey].hasOwnProperty(childKey);
  });
}

// Usage:
const parentsForChild1 = getParentKeysForChild('1', yourSourceData);
// Returns: ["AAA", "BBB", "CCC"]

Pros & Cons: #

• ✅ No extra storage, no syncing required
• ❌ Performance drops with very large datasets (since it iterates all parent keys every time)

3. Auto-Maintained Child Key References (If You Want Embedded Associations) #

If you prefer having parent references directly in child objects (like your original keys field idea), use a data wrapper or proxy to automate the updates instead of doing it manually.

Example with JavaScript Proxy: #

// Initialize your base data with empty keys arrays
const data = {
  AAA: { 
    "1": { value: "Sample Data 1", keys: ["AAA"] }, 
    "2": { value: "Sample Data 2", keys: ["AAA"] } 
  }
};

// Create a proxy to auto-sync keys when data changes
const dataProxy = new Proxy(data, {
  set(target, parentKey, childObj) {
    // Add parent key to every child's keys array
    Object.keys(childObj).forEach(childKey => {
      if (!childObj[childKey].keys) childObj[childKey].keys = [];
      if (!childObj[childKey].keys.includes(parentKey)) {
        childObj[childKey].keys.push(parentKey);
      }
    });
    target[parentKey] = childObj;
    return true;
  },
  deleteProperty(target, parentKey) {
    // Remove parent key from all its children's keys arrays
    if (target[parentKey]) {
      Object.keys(target[parentKey]).forEach(childKey => {
        const child = target[parentKey][childKey];
        if (child.keys) {
          child.keys = child.keys.filter(k => k !== parentKey);
        }
      });
    }
    delete target[parentKey];
    return true;
  }
});

// Example: Add a new parent with children—keys auto-update
dataProxy.DDD = {
  "1": { value: "Sample Data X" },
  "5": { value: "Sample Data Y" }
};
// Now dataProxy.DDD["1"].keys = ["DDD"]

This keeps your child objects self-contained with parent references, but you never have to manually edit the keys field.

内容的提问来源于stack exchange，提问作者helloworld1234