JavaScript: how do I flatten an object like this

Question

how do we implement a util flatten to flat this

myMap = {
  'a': 5,
  'b': 6,
  'c': {
    'f': 9,
    'g': {
      'm': 17,
      'n': 3
    }
  }
}

to

flatten(myMap) = {
  'a': 5,
  'b': 6,
‍‌‌‍‌‍‌‍‍‌‍‍‍‍‍‌‍‌‍‍ 'c.f': 9,
  'c.g.m': 17,
  'c.g.n': 3,
}

?

I found here is an implementation https://github.com/lukeed/flattie/blob/master/src/index.js but I couldn't understand the code. Can someone please give me a more readable version?

Answer 1

This is the most optimal method to solve your problem sir.

// Declare an object
myMap = {
    'a': 5,
    'b': 6,
    'c': {
      'f': 9,
      'g': {
         'm': 17,
         'n': 3
  }
 }
}
// Declare a flatten function that takes
// object as parameter and returns the
// flatten object
const flattenObj = (myMap) => {

// The object which contains the
// final result
let result = {};

// loop through the object "ob"
for (const i in myMap) {

    // We check the type of the i using
    // typeof() function and recursively
    // call the function again
    if ((typeof myMap[i]) === 'object' && !Array.isArray(myMap[i])) {
        const temp = flattenObj(myMa**strong text**p[i]);
        for (const j in temp) {

            // Store temp in result
            result[i + '.' + j] = temp[j];
        }
    }

    // Else store ob[i] in result directly
    else {
        result[i] = myMap[i];
    }
}
return result;
};

console.log(flattenObj(myMap));

Thank you.

Answer 2

You can use this code:

 myMap = { 'a': 5, 'b': 6, 'c': { 'f': 9, 'g': { 'm': 17, 'n': 3 } } } function flatten(obj, pKey = null, res = {}) { for (let key in obj) { const name = pKey ? `${pKey}.${key}` : key; if (typeof obj[key] === "object" && !Array.isArray(obj[key])) { flatten(obj[key], name, res); } else { res[name] = obj[key]; } } return res; } console.log(flatten(myMap))

you can use it by flatten(myMap) . Actually, it's simple, but sometimes it makes confusion. how it works is by looping then checking, if it is an object then calling itself again (recursive) to create a key object deeply and if not then create a key object until there.

Answer 3

Here is perhaps a slightly simpler version:

 const inputObject = { a: 5, b: 6, c: { f: 9, g: { m: 17, n: 3 } } } function flatten(input, keys = [], output = {}) { for (key in input) { const value = input[key] const combinedKeys = [...keys, key] if (typeof value === 'object') { output = flatten(value, combinedKeys, output) } else { output[combinedKeys.join('.')] = value } } return output } console.log(flatten(inputObject)) /* Logs: * { * "a": 5, * "b": 6, * "cf": 9, * "cgm": 17, * "cgn": 3 * } */

The idea is to recursively look at all properties of the object and build a . -separated key as we go deeper until we reach a leaf value.

You can read more about recursive functions here: https://www.freecodecamp.org/news/what-is-recursion-in-javascript/