Javascript 展平对象数组中的嵌套对象

我正在使用Typescript，我有以下对象结构：

    {
  a: "somedata",
  b: "somedata2",
  c: [
    {
      name: "item1",
      property1: "foo",
      property2: "bar",
      property3:{property4:"baz",property5:"foo2"},
      property6:"bar2"
    },
    { name: "item2", properties:{...} },
  ]
};

我需要在同一级别上设置每个项目的属性，以便使我的最终对象如下所示：

 {
  a: "somedata",
  b: "somedata2",
  c: [
    {
      name: "item1",
      property1: "foo",
      property2: "bar",
      property4:"baz",
      property5:"foo2",
      property6:"bar2"
    },
    { name: "item2",
      property1:"...",
      property2:"..." },
  ]
};

编辑： 这是我现在唯一拥有的东西：

  getFinalObject(objectId){
    
        return this.http.get(
            this.API_URL + "/object/"+objectId,
            this.getHeaders()
          ).pipe(
            map((res:any) =>{//my final object should be mapped here
});
    }

---

假设没有比示例中给出的嵌套级别更高的嵌套，并且嵌套只发生在键“c”中，下面的代码可能就是您的意思。此外，由于删除和插入时typescript提出的限制，必须使用类型“any”来声明对象

let s:any =   {
  a: "somedata",
  b: "somedata2",
  c: [
    {
      name: "item1",
      property1: "foo",
      property2: "bar",
      property3:{property4:"baz",property5:"foo2"},
      property6:"bar2"
    },
    { name: "item2", 
      property1: "foo",
      property2: "bar",
      property3:{property4:"baz",property5:"foo2"},
      property6:"bar2"  
    },
  ]
};



for(let i:number=0; i<s.c.length; i++) {
    let KEYS:string[] = Object.keys(s.c[i]);
    let VALS:string[] = Object.values(s.c[i]);
    let tempKEYS:string[] = [];
    let tempVALS:string[] = [];
    for(let j:number=0; j<VALS.length; j++) {
        if(typeof VALS[j] === "object") {
            tempKEYS.push(...Object.keys(VALS[j]));
            tempVALS.push(...Object.values(VALS[j]));
            delete s.c[i][KEYS[j]];
        }
    }
    for(let j:number=0; j< tempKEYS.length;j++) {
        s.c[i][tempKEYS[j]] = tempVALS[j];
    }
}

console.log(s);

s:any={
a:“一些数据”，
b:“somedata2”，
c:[
{
名称：“项目1”，
房地产1：“富”，
物业2：“酒吧”，
property3:{property4:“baz”，property5:“foo2”}，
物业6：“bar2”
},
{名称：“项目2”，
房地产1：“富”，
物业2：“酒吧”，
property3:{property4:“baz”，property5:“foo2”}，
物业6：“bar2”
},
]
};
for（让i:number=0；i这里有一个通用函数，它应该在所有深度都能工作（除非你用一个非常深的对象来破坏调用堆栈）

const flatten=（值：T）：记录=>
Object.fromEntries(
Object.entries（值）
.flatMap（[k，v]）=>
typeof v==“对象”&&v！==null
？（数组。isArray（v）
？[[k，v.map（x=>typeof x==“object”？展平（x）：x）]]
：Object.entries（展平（v）））
：[[k，v]]））

属性对象是否可以拥有自己的属性对象？嵌套对象可以有多深（无限深？）请向我们展示您尝试的代码我的属性对象内部最多可以有两层深度（嵌套对象），我只需要一个级别就可以了。你能举一个更高级别的例子吗？我可能会尝试适当地保留类型以获得乐趣，但这是一项更复杂的工作。
interface Inner {
    [property : string] : string
}

interface Outer {
    a : string,
    b : string,
    c : Inner[]
}

let s:any =   {
  a: "somedata",
  b: "somedata2",
  c: [
    {
      name: "item1",
      property1: "foo",
      property2: "bar",
      property3:{property4:"baz",property5:"foo2"},
      property6:"bar2"
    },
    { name: "item2", 
      property1: "foo",
      property2: "bar",
      property3:{property4:"baz",property5:"foo2"},
      property6:"bar2"  
    },
  ]
};


let newS : Outer = {
    a : s.a,
    b : s.b,
    c : [] 
};



for(let i:number=0; i<s.c.length; i++) {
    newS.c.push({});
    let KEYS:string[] = Object.keys(s.c[i]);
    let VALS:string[] = Object.values(s.c[i]);
    console.log(VALS.length);
    for(let j:number=0; j<VALS.length; j++) {
        if(typeof VALS[j] === 'string') {
            newS.c[i][KEYS[j]] = VALS[j];
        }
        else if(typeof VALS[j] === 'object') {
            let innerKEYS : string[] = Object.keys(VALS[j]);
            let innerVALS : string[] = Object.values(VALS[j]);
            for(let k:number=0; k<innerKEYS.length; k++) {
                newS.c[i][innerKEYS[k]] = innerVALS[k];
            }
        }
    }
}

console.log(newS);

const flatten = <T extends Record<string, any>>(value: T): Record<string, any> =>
    Object.fromEntries(
        Object.entries(value)
            .flatMap(([k, v]) =>
                typeof v === "object" && v !== null
                    ? (Array.isArray(v)
                        ? [[k, v.map(x => typeof x === "object" ? flatten(x) : x)]]
                        : Object.entries(flatten(v)))
                    : [[k, v]]))