Typescript 使用RXJS按特定对象属性将平面对象列表分组到嵌套列表中

我有这样的收藏：

FlatObject
[ 
  {
    id:"1",
    name:"test1",
    group: "A"
  },
  {
    id:"2",
    name:"test2",
    group: "B"
  },
{
    id:"3",
    name:"test3",
    group: "B"
  },
  {
    id:"4",
    name:"test4",
    group: "A"
  },
]

NestedObjects

 [{
    "group": "A",
    "objectProps": [{
        "id": "1"
        "name": "test1",

    },
    {
        "id": "4"
        "name": "test4",

    }]
},
{
    "group": "B",
    "objectProps": [{
        "id": "2"
        "name": "test2",

    },
    {
        "id": "3"
        "name": "test4",

    }]
}]

我想使用Observable和RxJs，得到一个按组分组的字典，如下所示：

FlatObject
[ 
  {
    id:"1",
    name:"test1",
    group: "A"
  },
  {
    id:"2",
    name:"test2",
    group: "B"
  },
{
    id:"3",
    name:"test3",
    group: "B"
  },
  {
    id:"4",
    name:"test4",
    group: "A"
  },
]

NestedObjects

 [{
    "group": "A",
    "objectProps": [{
        "id": "1"
        "name": "test1",

    },
    {
        "id": "4"
        "name": "test4",

    }]
},
{
    "group": "B",
    "objectProps": [{
        "id": "2"
        "name": "test2",

    },
    {
        "id": "3"
        "name": "test4",

    }]
}]

当我尝试这个操作符时，我认为它更接近于reduce或者just use do，我想做一些类似于这段代码的事情，我对一个集合对象有副作用

let collectionNestedOBjects: NestedObjects[];
.....
.map((response: Response) => <FlaTObject[]>response.json().results)
.reduce(rgd, rwgr => { 

              // Soudo Code

              // Create NestedObject with group

              // Check if collectionNestedOBjects has an object with that group name
                      Yes: Create a objectProps and add it to the objectProps collection 
                      No: Create a new NestedObject in collectionNestedObjects and Create a objectProps and add it to the objectProps collection 

          }
          ,new ReadersGroupDetail());

let collectionNestedOBjects:NestedObjects[]；
.....
.map（（response:response）=>response.json（）.results）
.reduce（rgd，rwgr=>{
//Soudo代码
//使用组创建嵌套对象
//检查collectionNestedOBjects是否有具有该组名称的对象
是：创建objectProps并将其添加到objectProps集合
否：在CollectionNestedObject中创建新的NestedObject，创建objectProps并将其添加到objectProps集合中
}
，new ReadersGroupDetail（））；

是否有另一个操作员可以使该投影清晰且无副作用

您可以使用

.map（）

运算符并映射到所需的类型：

const data: Observable<NestedObject[]> = getInitialObservable()
  .map((response: Response) => <FlatObject[]>response.json().results)
  .map((objects: FlatObject[]) => {
    // example implementation, consider using hashes for faster lookup instead
    const result: NestedObjects[] = [];

    for (const obj of objects) {
      // get all attributes except "group" into "props" variable
      const { group, ...props } = obj;
      let nestedObject = result.find(o => o.group === group);
      if (!nestedObject) {
        nestedObject = { group, objectProps: [] };
        result.push(nestedObject);
      }
      nestedObject.objectProps.push(props);
    }
     return result;
  });

const data:Observable=getInitialObservable（）
.map（（response:response）=>response.json（）.results）
.map（（对象：FlatObject[]）=>{
//示例实现，考虑使用散列来进行更快查找。
常量结果：嵌套对象[]=[]；
for（对象的常量对象）{
//将除“组”之外的所有属性放入“props”变量中
const{group，…props}=obj；
让nestedObject=result.find（o=>o.group==group）；
如果（！nestedObject）{
nestedObject={group，objectProps:[]}；
结果：推送（嵌套对象）；
}
nestedObject.objectProps.push（props）；
}
返回结果；
});

您可以使用

.map（）

运算符并映射到所需的类型：

const data: Observable<NestedObject[]> = getInitialObservable()
  .map((response: Response) => <FlatObject[]>response.json().results)
  .map((objects: FlatObject[]) => {
    // example implementation, consider using hashes for faster lookup instead
    const result: NestedObjects[] = [];

    for (const obj of objects) {
      // get all attributes except "group" into "props" variable
      const { group, ...props } = obj;
      let nestedObject = result.find(o => o.group === group);
      if (!nestedObject) {
        nestedObject = { group, objectProps: [] };
        result.push(nestedObject);
      }
      nestedObject.objectProps.push(props);
    }
     return result;
  });

const data:Observable=getInitialObservable（）
.map（（response:response）=>response.json（）.results）
.map（（对象：FlatObject[]）=>{
//示例实现，考虑使用散列来进行更快查找。
常量结果：嵌套对象[]=[]；
for（对象的常量对象）{
//将除“组”之外的所有属性放入“props”变量中
const{group，…props}=obj；
让nestedObject=result.find（o=>o.group==group）；
如果（！nestedObject）{
nestedObject={group，objectProps:[]}；
结果：推送（嵌套对象）；
}
nestedObject.objectProps.push（props）；
}
返回结果；
});

是，这项工作缺少我添加和测试的返回结果，它对数据进行了分组是，这项工作缺少我添加和测试的返回结果，它对数据进行了分组