展平 JavaScript 嵌套对象

Question

我有一个嵌套对象，如下所示：

let obj = { 
    F:{
        asian: {
            "35-44": 1,
            "55-": 1,
        },
        "asian/black": {
            "0-24": 1,
            "35-44": 1,
            "45-54": 2,
        },
    },
    M:{
        asian: {
            "35-44": 1,
            "55-": 1,
        },
        white: {
            "0-24": 1,
            "35-44": 1,
            "45-54": 2,
        },
    },

}

我想将对象展平：

res = {
    F: 6,
    M: 6,
    asian: 4,
    "asian/black": 4,
    white: 4, 
    "0-24": 2,
    "35-44": 4,
    "45-54": 4,
    "55-": 2,
}

res中的每个值都应该是最深的对象值（F，M）和具有相同键的对象值（0-24，35-44...）的总和。我觉得这可以使用递归来完成，但无法做到。我写的代码：

let returnVal = 0
const flatten = (obj, prefix = '', res = {}) => {

  return Object.entries(obj).reduce((r, [key, val]) => {
    if(typeof val === 'object'){ 
      flatten(val, key, r)
    } else {
      res[key] = val
      returnVal = val;
    }

    if (key in res) {
        res[key] += returnVal
    } else {
        res[key] = 0
        res[key] += returnVal
    }
    
    return r
  }, res)
}
console.log(flatten(obj))

它会输出：

result = {
"0-24": 2,
"35-44": 2,
"45-54": 4,
"55-": 2,
F: 2,
M: 2,
asian: 2,
"asian/black": 2,
white: 2,
}

F、M 和其他一些键不正确。谢谢！

Answer 1

另一种可能更简单的方法如下：

const consolidate = (obj, path = [], results = {}) =>
  Object .entries (obj) .reduce ((results, [k, v]) => 
    Object (v) === v 
      ? consolidate (v, [...path, k], results)
      : [...path, k] .reduce (
          (results, n) => ({...results, [n] : (results[n] || 0) + v}), 
          results
        ),
  results)

const data = {F: {asian: {"35-44": 1, "55-": 1}, "asian/black": {"0-24": 1, "35-44": 1, "45-54": 2}}, M: {asian: {"35-44": 1, "55-": 1}, white: {"0-24": 1, "35-44": 1, "45-54": 2}}}

console .log (consolidate (data))

.as-console-wrapper {min-height: 100% !important; top: 0}

我们递归地跟踪通过对象的路径，例如 ['F', 'asian/black', '45-54'] 或 ['M', 'white'] 或简单的 ['f'] 以及包含最终结果的对象。当我们当前节点的值是一个对象时，我们递归，将当前属性名称添加到路径中。如果不是（因此，对于此数据，它必须命中一个数字），我们遇到一个基本情况，在这种情况下，我们获取当前路径中的每个节点，并通过将该数字添加到结果对象中节点的值来更新结果对象，或者如果该值不存在，则将其设置为当前值。

默认参数存在潜在问题，如another Q & A 中所述。如果有人试图在输入对象数组上直接使用map consolidate 函数，它将失败。如果这是一个问题，很容易将默认参数交换为包装函数：

const _consolidate = (obj, path, results) =>
  Object .entries (obj) .reduce ((results, [k, v]) => 
    Object (v) === v 
      ? _consolidate (v, [...path, k], results)
      : [...path, k] .reduce (
          (results, n) => ({...results, [n] : (results[n] || 0) + v}), 
          results
        ),
  results)

const consolidate = (obj) => 
  _consolidate (obj, [], {})

Answer 2

const data = {
  F: {
    asian: {
      "35-44": 1,
      "55-": 1,
    },
    "asian/black": {
      "0-24": 1,
      "35-44": 1,
      "45-54": 2,
    },
  },
  M: {
    asian: {
      "35-44": 1,
      "55-": 1,
    },
    white: {
      "0-24": 1,
      "35-44": 1,
      "45-54": 2,
    },
  },
};

const isObject = obj => Object.prototype.toString.call(obj) === "[object Object]";

function nestKeys(obj, parent = "") {
  return Object.keys(obj).map(key => {
    const k = parent.length ? [parent, key].join(".") : key;

    if (!isObject(obj[key])) {
      return k;
    }

    return nestKeys(obj[key], k);
  }).flat();
}

function flatObj(obj) {
  const map = {};
  const keys = nestKeys(obj);

  keys.forEach(nestedKey => {
    const splited = nestedKey.split(".");

    const val = splited.reduce((acc, cur) => acc[cur], obj);

    splited.forEach(k => {
      map[k] = (map[k] || 0) + val;
    })
  });

  return map;
}


console.log(flatObj(data));