主页 / 问题 / 1581312
Accepted
Вячеслав
Asked:2024-05-23 15:07:36 +0000 UTC2024-05-23 15:07:36 +0000 UTC

嵌套对象的解析和重新计算

  • 772
  • 有一个产品对象
  • 它包含构成产品的组件
  • 组件表示为嵌套对象
  • 组件可以很简单也可以很复杂
  • 对于简单组件和复杂组件（第一嵌套层），指示了创建产品所需的数量
  • 复杂组件有一个空对象，必须在嵌套解析期间填充
let product = {
    'VOP': { complex: true, count: 51, consist: {} },
    'gem': { complex: false, count: 2 }
}
  • 有一个复杂组件的对象
  • 复杂组件包含简单组件和复杂组件（N 嵌套）
  • 对于嵌套组件，指示创建该组件所在的一个组件所需的数量
let complexRes = {
    'VOP': {
        'vrs': { complex: false, count: 3 },
        'sop': { complex: false, count: 1 },
        'CBP': { complex: true, count: 3, consist: { } }
    },
    'CBP': {
        'ab': { complex: false, count: 10 }
    }
}
  • 需要重新计算嵌套组件数量并修改产品对象
  • 结果应该是这样的：
product = {
    'VOP': { complex: true, count: 51, consist: {
        'vrs': { complex: false, count: 153 },
        'sop': { complex: false, count: 51 },
        'CBP': { complex: true, count: 153, consist: {
            'ab': { complex: false, count: 1530 }
        } }
      } },
    'gem': { complex: false, count: 2 }
}

我尝试这样做，但我很困惑


let complexConsist = {}

for(let key in product) {
    if(product[key]['complex']){
        calc(key, product[key]);
    }
}

function calc(key, obj) {
    complexConsist[key] = JSON.parse(JSON.stringify(obj));
    for(let keyInner in complexRes[key]) {
        if(complexRes[key][keyInner]['complex']) {
            
            // дальше запутался, наговнокодил, выкладывать нет смысла видимо )
        }
    }
}

也许有人了解需要什么并可以帮助我完成它？）

UPD：一个更复杂的选项：

const complexResInit = {
  'VOP': {
    'vrs': { complex: false, count: 3 },
    'sop': { complex: false, count: 1 },
    'CBP': { complex: true, count: 3, consist: { } }
  },
  'CBP': {
    'ab': { complex: false, count: 10 }
  },
  'MM': {
    'mold': { complex: false, count: 10 },
    'VOP': { complex: true, count: 10, consist: { } }
  }
}

const productInit = {
  'VOP': { complex: true, count: 51, consist: {} },
  'gem': { complex: false, count: 2 },
  'MM': { complex: true, count: 1, consist: {} } 
}
javascript

1 个回答

  1. Best Answer

    递归用于遍历相似的多级对象

    const complexResInit = {
  'VOP': {
    'vrs': { complex: false, count: 3 },
    'sop': { complex: false, count: 1 },
    'CBP': { complex: true, count: 3, consist: { } }
  },
  'CBP': {
    'ab': { complex: false, count: 10 }
  },
  'MM': {
    'mold': { complex: false, count: 10 },
    'VOP': { complex: true, count: 10, consist: { } }
  }
}

const productInit = {
  'VOP': { complex: true, count: 51, consist: {} },
  'gem': { complex: false, count: 2 },
  'MM': { complex: true, count: 1, consist: {} } 
}

function compareProducts(product, complexRes, multiplier = 1) {
  const res = {};
  for(let key in product) {
    res[key] = { ...product[key] };
    res[key].count *= multiplier;
    if (product[key].complex) res[key].consist = compareProducts(complexRes[key], complexRes, res[key].count)
  }
  return res;
}

const result = compareProducts(productInit, complexResInit)
console.log(result);

    要正确编译递归遍历，您需要了解使用哪些标志来确定需要开始递归以及将哪些内容传递给下一次迭代。

    对于您的对象，我们会遍历产品对象，如果遇到复杂的对象，我们会递归调用该函数，并且传递的不是产品中的元素，而是复杂产品中的元素，然后将其添加到结果中目的

    “数组上”递归的另一个例子：

    function compareProductsArray(product, complexRes, multiplier = 1) {
  return Object.entries(product).reduce((acc, [key, val]) => {
    acc[key] = { ...val };
    acc[key].count *= multiplier;
    if (val.complex) acc[key].consist = compareProductsArray(complexRes[key], complexRes, acc[key].count);
    return acc;
  }, {});
}
    • 1

相关问题