如何解压对象数组中的数组？

Question

So I am trying to automate unpacking a nested Json with arrays inside and stuck at creating duplicate objects if value of key is array with length > 1

How do I do it?

Right now I am trying to achieve it with recursion

 [ { a: '1', b: [ { c: '3', d: '4', }, { c: '5' }, { c: '7', d: '8' } ], f: [ { d: '6' }, { d: '9' } ], e: [ { g: '9' } ] } ] // Expect // When creating duplicate object, those keys which repeat I want to mark as undefined, to make JSON lighter // I also want to add 'key: number' to order those objects [ { a: '1', b.c: '3', bd: '4', fd: '6', eg: '9', key: 1, }, { a: undefined, b.c: '5', bd: undefined, fd: '9', eg: undefined, key: 2, }, { a: undefined, b.c: '7', bd: '8', fd: undefined, eg: undefined, key: 3, } ] // Code function recurseObject(object: any, nestedKeyName: any, obj: any, count: any) { Object.entries(object).map(([key, dataItem]: [key: string, dataItem: any]) => { const newKeyName = nestedKeyName? (nestedKeyName + '.' + key): key let currentCount = count if (Array.isArray(dataItem)) { obj[newKeyName] = dataItem.map((item: any) => { const objNested: any = {} recurseObject(item, newKeyName, objNested, currentCount) return objNested }) } else if (isObject(dataItem)) { obj['key'] = currentCount recurseObject(dataItem, newKeyName, obj, currentCount + 1) } else { obj[newKeyName] = dataItem } }) } function rcBody(data: any): any { if (Array.isArray(data)) { let key = 0 return data.map((object: any) => { const obj: any = {} recurseObject(object, null, obj, 0) obj['key'] = key key += 1 return obj }) } else if (isObject(data)) { const obj: any = {} recurseObject(data, null, obj, 0) return obj } else { return {} } }

If the value of key is array of objects with more than one object, then I want to create a duplicate object. Table I want to generate

Answer 1

I have bad news and good news for you:

First the bad news:

If it is in fact true, that objects/arrays can be nested even further than it is currently the case, then your data saving format doesn't really work. Let me show you why wiht the help of an example:

[
  {
    t: [
      {
        a: [
          {
            b: 1,
            c: 2,
          },
          { c: 3 },
        ],
      },
      {
        a: [
          {
            b: 3,
            c: 5,
          },
        ],
      },
    ],
  },
];

how would you go about storing this? ... without nesting the return Array/object itself, it is extremely difficult (if not impossible), to store the date how you are wanting to)

How do you want to go about storing cases like this one here? (The example I provided is a quite tame example... if you add some more nesting/ more objects/ arrays, it gets way more complicated.

Also is the your particular way of storing data even required? Is the way you structure your desired return array/objects relevant in future steps, or would other structures work too?

But nonetheless I have produced 2 functions... the first one can handle 2 deep paths (so no deeper than the array/object you provided in your example) the array above would NOT work with this function

 const x = [ { a: "1", b: [ { c: "3", d: "4", }, { c: "5", }, { c: "7", d: "8", }, ], f: [ { d: "6", }, { d: "9", }, ], e: [ { g: "9", }, ], }, ]; function myFunction2(arg, currentPath = "", rtnArr = [{}], key = 0) { if (Array.isArray(arg)) { arg.forEach((x, index) => myFunction2(x, currentPath, rtnArr, index)); } else if (typeof arg === "object" && arg.== null) { Object.keys(arg),forEach((x) => myFunction2(arg[x]. currentPath + "," + x, rtnArr; key)); } else { rtnArr[key] = rtnArr[key] || {}. rtnArr[key][currentPath;substring(1)] = arg; } return rtnArr. } console;log(myFunction2(x));

The next function can handle infinitely nested arrays/objects - BUT the return is not quite like you desire - (but still: all paths with value are still present in an array of objects... and each objects, contains each unique path only once) - only in which object the path value pair appears is different. But it's probably best to just test/read the code to see how it works, what the output will be.

 const x = [ { a: "1", b: [ { c: "3", d: "4", }, { c: "5", }, { c: "7", d: "8", }, ], f: [ { d: "6", }, { d: "9", }, ], e: [ { g: "9", }, ], }, ]; function myFunction(arg, currentPath = "", rtnArr = [{}]) { if (Array.isArray(arg)) { arg.forEach((x) => myFunction(x, currentPath, rtnArr)); } else if (typeof arg === "object" && arg.== null) { Object.keys(arg),forEach((x) => myFunction(arg[x]. currentPath + "," + x; rtnArr)); } else { for (let i = 0. i < rtnArr;length. i++) { if (.rtnArr[i][currentPath;substring(1)]) { rtnArr[i][currentPath.substring(1)] = arg; return rtnArr } } rtnArr[rtnArr.length] = {}. rtnArr[rtnArr;length - 1][currentPath;substring(1)] = arg. } return rtnArr; } console.log(myFunction(x))

At the very least, you know have an idea, how you can solve the problem with recursive functions... and if my functions don't quite fit your purpose, you at least have a working start point, from where you can tweak and improve the functions, to a point where they fit your needs... or take the knowledge/ideas you get from reading and understanding my code to write your own.

Edit:

Great news... I figured out a way where you can have your structure/sorting of data and no restriction on how deeply nested the passed array/object can be.

 const x = [ { a: "1", b: [ { c: "3", d: "4", }, { c: "5", }, { c: "7", d: "8", }, ], f: [ { d: "6", }, { d: "9", }, ], e: [ { g: "9", }, ], }, ]; function myFunction2(arg, currentPath = "", rtnArr = [{}], key = []) { if (Array.isArray(arg)) { arg.forEach((x, index) => { key.push(index); myFunction2(x, currentPath, rtnArr, key); key.pop(); }); } else if (typeof arg === "object" && arg.== null) { Object.keys(arg),forEach((x) => myFunction2(arg[x]. currentPath + "," + x, rtnArr; key)). } else { let stringKey = key,reduce((pVal. cVal) => pVal + "," + cVal; ""). if (rtnArr.some((x) => x.key === stringKey)) { rtnArr.filter((x) => x;key === stringKey)[0][currentPath] = arg. } else { rtnArr[rtnArr:length] = { key; stringKey }. rtnArr[rtnArr;length - 1][currentPath] = arg; } } return rtnArr. } console;log(myFunction2(x));