试试这个:

    function getFlattenObject(data, response = {}) {
  for (const key in data) {
    if (typeof data[key] === 'object' && !Array.isArray(data[key])) {
      getFlattenObject(data[key], response);
    } else {
      response[key] = data[key];
    }
  }
  return response;
}

三年半后……

对于我自己的项目，我想在mongoDB点表示法中平坦JSON对象，并提出了一个简单的解决方案:

/**
 * Recursively flattens a JSON object using dot notation.
 *
 * NOTE: input must be an object as described by JSON spec. Arbitrary
 * JS objects (e.g. {a: () => 42}) may result in unexpected output.
 * MOREOVER, it removes keys with empty objects/arrays as value (see
 * examples bellow).
 *
 * @example
 * // returns {a:1, 'b.0.c': 2, 'b.0.d.e': 3, 'b.1': 4}
 * flatten({a: 1, b: [{c: 2, d: {e: 3}}, 4]})
 * // returns {a:1, 'b.0.c': 2, 'b.0.d.e.0': true, 'b.0.d.e.1': false, 'b.0.d.e.2.f': 1}
 * flatten({a: 1, b: [{c: 2, d: {e: [true, false, {f: 1}]}}]})
 * // return {a: 1}
 * flatten({a: 1, b: [], c: {}})
 *
 * @param obj item to be flattened
 * @param {Array.string} [prefix=[]] chain of prefix joined with a dot and prepended to key
 * @param {Object} [current={}] result of flatten during the recursion
 *
 * @see https://docs.mongodb.com/manual/core/document/#dot-notation
 */
function flatten (obj, prefix, current) {
  prefix = prefix || []
  current = current || {}

  // Remember kids, null is also an object!
  if (typeof (obj) === 'object' && obj !== null) {
    Object.keys(obj).forEach(key => {
      this.flatten(obj[key], prefix.concat(key), current)
    })
  } else {
    current[prefix.join('.')] = obj
  }

  return current
}

特性和/或注意事项

它只接受JSON对象。因此，如果你传递类似{a:() =>{}}的东西，你可能得不到你想要的! 它删除空数组和对象。所以这个{a: {}， b:[]}被平化为{}。

这里有另一个方法，比上面的答案运行得慢(大约1000毫秒)，但有一个有趣的想法:-)

它不是遍历每个属性链，而是只选择最后一个属性，并使用一个查找表来存储其余属性，从而存储中间结果。这个查找表将被迭代，直到没有剩余的属性链，并且所有值都驻留在未协同的属性上。

JSON.unflatten = function(data) {
    "use strict";
    if (Object(data) !== data || Array.isArray(data))
        return data;
    var regex = /\.?([^.\[\]]+)$|\[(\d+)\]$/,
        props = Object.keys(data),
        result, p;
    while(p = props.shift()) {
        var m = regex.exec(p),
            target;
        if (m.index) {
            var rest = p.slice(0, m.index);
            if (!(rest in data)) {
                data[rest] = m[2] ? [] : {};
                props.push(rest);
            }
            target = data[rest];
        } else {
            target = result || (result = (m[2] ? [] : {}));
        }
        target[m[2] || m[1]] = data[p];
    }
    return result;
};

它目前使用表的数据输入参数，并在上面放置了许多属性-一个非破坏性的版本也应该是可能的。也许巧妙地使用lastIndexOf会比正则表达式执行得更好(取决于正则表达式引擎)。

在这里看到它的行动。

这是我的。它在谷歌应用程序脚本中在一个相当大的对象上运行<2ms。它使用破折号而不是点作为分隔符，并且它不像提问者的问题中那样专门处理数组，但这是我想要的。

function flatten (obj) {
  var newObj = {};
  for (var key in obj) {
    if (typeof obj[key] === 'object' && obj[key] !== null) {
      var temp = flatten(obj[key])
      for (var key2 in temp) {
        newObj[key+"-"+key2] = temp[key2];
      }
    } else {
      newObj[key] = obj[key];
    }
  }
  return newObj;
}

例子:

var test = {
  a: 1,
  b: 2,
  c: {
    c1: 3.1,
    c2: 3.2
  },
  d: 4,
  e: {
    e1: 5.1,
    e2: 5.2,
    e3: {
      e3a: 5.31,
      e3b: 5.32
    },
    e4: 5.4
  },
  f: 6
}

Logger.log("start");
Logger.log(JSON.stringify(flatten(test),null,2));
Logger.log("done");

示例输出:

[17-02-08 13:21:05:245 CST] start
[17-02-08 13:21:05:246 CST] {
  "a": 1,
  "b": 2,
  "c-c1": 3.1,
  "c-c2": 3.2,
  "d": 4,
  "e-e1": 5.1,
  "e-e2": 5.2,
  "e-e3-e3a": 5.31,
  "e-e3-e3b": 5.32,
  "e-e4": 5.4,
  "f": 6
}
[17-02-08 13:21:05:247 CST] done

试试这个:

    function getFlattenObject(data, response = {}) {
  for (const key in data) {
    if (typeof data[key] === 'object' && !Array.isArray(data[key])) {
      getFlattenObject(data[key], response);
    } else {
      response[key] = data[key];
    }
  }
  return response;
}

我想要一种方法，这样我就可以轻松地将我的json数据转换为csv文件。 这个场景是:我从某个地方查询数据，然后收到某个模型的数组，比如银行提取。 下面的方法用于解析这些条目中的每一个。

function jsonFlatter(data, previousKey, obj) {
    obj = obj || {}
    previousKey = previousKey || ""
    Object.keys(data).map(key => {
        let newKey = `${previousKey}${previousKey ? "_" : ""}${key}`
        let _value = data[key]
        let isArray = Array.isArray(_value)
        if (typeof _value !== "object" || isArray || _value == null) {
            if (isArray) {
                _value = JSON.stringify(_value)
            } else if (_value == null) {
                _value = "null"
            }
            obj[newKey] = _value
        } else if (typeof _value === "object") {
            if (!Object.keys(_value).length) {
                obj[newKey] = "null"
            } else {
                return jsonFlatter(_value, newKey, obj)
            }
        }
    })
    return obj
}

这样，我可以依靠对象模型的键和内键的一致性，但是数组只是字符串化的，因为我不能依赖它们的一致性。此外，空对象变成字符串“null”，因为我仍然希望它的关键出现在最终结果中。

使用的例子:

const test_data = {
    a: {
        aa: {
            aaa: 4354,
            aab: 654
        },
        ab: 123
    },
    b: 234,
    c: {},
    d: []
}

console.log('result', jsonFlatter(test_data)) 

#### output
{
  "a_aa_aaa": 4354,
  "a_aa_aab": 654,
  "a_ab": 123,
  "b": 234,
  "c": "null",
  "d": "[]"
}