Javascript 减少时间复杂性并返回格式化对象

我们有一个JSON对象，它由需要以特定格式创建JSON的记录组成，以便将来可以使用创建的对象： 下面是JSON，我们需要从中创建另外六个JSON对象，它们由唯一（3）和分组（3）记录组成

您可以发现每个Tin、Npi和Speciality键都有多个与其他键映射的记录。（例如，我显示了2条记录[Tin:123123有两个Npi 12342345]）

独特的罐头：

[{Tin: "123123", TinName: "TinName1"}
{Tin: "234234", TinName: "TinName2"}
{Tin: "345345", TinName: "TinName3"}
{Tin: "456456", TinName: "TinName4"}]

独特的NPI：

[{Npi: "1234", NpiName: "Sample1"}
{Npi: "2345", NpiName: "Sample2"}
{Npi: "3456", NpiName: "Sample3"}
{Npi: "4567", NpiName: "Sample4"}]

独特特色：

[{Speciality: "Speciality1"}
{Speciality: "Speciality2"}
{Speciality: "Speciality3"}
{Speciality: "Speciality4"}]

分组罐头。（通过这种方式，还创建了团体NPI和团体专业。）

代码：我使用了map（）和reduce（）以便可以获得唯一的记录。对于分组，我使用reduce（）。但从代码来看，数百万条记录的时间复杂性将增加。有没有办法在一次或两次迭代中获得结果

          //uniq Tin
          finalJson[0] = jsonFile.map(item => ({
            Tin: item.Tin,
            TinName: item.TinName
          })).reduce(function (previous, current) {
            const object = previous.filter(i => i.Tin === current.Tin);
            if (object.length === 0) {
              previous.push(current);
            }
            return previous;
          }, []);

          //uniq Npi
          finalJson[1] = jsonFile.map(item => ({
            Npi: item.Npi,
            NpiName: item.NpiName
          })).reduce(function (previous, current) {
            const object = previous.filter(i => i.Npi === current.Npi);
            if (object.length === 0) {
              previous.push(current);
            }
            return previous;
          }, []);

          //unq Speciality
          finalJson[2] = jsonFile.map(item => ({
            Speciality: item.Speciality
          })).reduce(function (previous, current) {
            const object = previous.filter(i => i.Speciality === current.Speciality);
            if (object.length === 0) {
              previous.push(current);
            }
            return previous;
          }, []);

          //groupedTin
            finalJson[3] = jsonFile.reduce((acc, cur) => {
            const { Tin, ...rest } = cur;
            if (!acc[Tin]) {
              acc[Tin] = [];
            }
            acc[Tin].push(rest);
            return acc;
          }, {});

          //groupedNpi
           finalJson[4] = jsonFile.reduce((acc, cur) => {
            const { Npi, ...rest } = cur;
            if (!acc[Npi]) {
              acc[Npi] = [];
            }
            acc[Npi].push(rest);
            return acc;
          }, {});

          //groupedSpeciality
          finalJson[5] = jsonFile.reduce((acc, cur) => {
            const { Speciality, ...rest } = cur;
            if (!acc[Speciality]) {
              acc[Speciality] = [];
            }
            acc[Speciality].push(rest);
            return acc;
          }, {});


          

---

首先，您应该合并

map

和

reduce

。请参见下一个示例：

//而不是
finalJson[0]=jsonFile.map（项=>({
锡：项目。锡，
TinName:item.TinName
})).reduce（功能（先前、当前）{
const object=previous.filter（i=>i.Tin===current.Tin）；
如果（object.length==0）{
前推（当前）；
}
返回上一个；
}, []);
//请试一试
jsonFile[0]。reduce（（上一个，{Tin，TinName}）=>
！previous.some（i=>i.Tin==Tin）
？[…先前，{Tin，TinName}]
：先前，[]
)

上面的例子只是给你的一个提示。无需链式筛选/映射/减少，您几乎可以始终只使用减少

请记住，reduce回调接收第三个参数-元素的索引。 因此，您不必编写

finalJson[3]

，只需签入索引即可

---

老实说，我没有足够的时间来回答更多的问题。

我在寻找一个优化的解决方案，在这个解决方案中，一次迭代可以创建所有uniq Json，并为分组Json进行一次集成。

{
 123123: [
  {
    "TinName": "TinName1",
    "Npi": "1234", "NpiName": "Sample1",
    "Speciality": "Speciality1"
  },
  {
    "TinName": "TinName1",
    "Npi": "2345", "NpiName": "Sample2",
    "Speciality": "Speciality2"
  }
 ],
  234234: [
  {
    "TinName": "TinName2",
    "Npi": "3456", "NpiName": "Sample3",
    "Speciality": "Speciality3"
  }
 ],
  345345: [
  {
    "TinName": "TinName3",
    "Npi": "3456", "NpiName": "Sample3",
    "Speciality": "Speciality4"
  }
 ],
  456456: [
  {
    "TinName": "TinName4",
    "Npi": "4567", "NpiName": "Sample4",
    "Speciality": "Speciality4"
  }
 ]
}

          //uniq Tin
          finalJson[0] = jsonFile.map(item => ({
            Tin: item.Tin,
            TinName: item.TinName
          })).reduce(function (previous, current) {
            const object = previous.filter(i => i.Tin === current.Tin);
            if (object.length === 0) {
              previous.push(current);
            }
            return previous;
          }, []);

          //uniq Npi
          finalJson[1] = jsonFile.map(item => ({
            Npi: item.Npi,
            NpiName: item.NpiName
          })).reduce(function (previous, current) {
            const object = previous.filter(i => i.Npi === current.Npi);
            if (object.length === 0) {
              previous.push(current);
            }
            return previous;
          }, []);

          //unq Speciality
          finalJson[2] = jsonFile.map(item => ({
            Speciality: item.Speciality
          })).reduce(function (previous, current) {
            const object = previous.filter(i => i.Speciality === current.Speciality);
            if (object.length === 0) {
              previous.push(current);
            }
            return previous;
          }, []);

          //groupedTin
            finalJson[3] = jsonFile.reduce((acc, cur) => {
            const { Tin, ...rest } = cur;
            if (!acc[Tin]) {
              acc[Tin] = [];
            }
            acc[Tin].push(rest);
            return acc;
          }, {});

          //groupedNpi
           finalJson[4] = jsonFile.reduce((acc, cur) => {
            const { Npi, ...rest } = cur;
            if (!acc[Npi]) {
              acc[Npi] = [];
            }
            acc[Npi].push(rest);
            return acc;
          }, {});

          //groupedSpeciality
          finalJson[5] = jsonFile.reduce((acc, cur) => {
            const { Speciality, ...rest } = cur;
            if (!acc[Speciality]) {
              acc[Speciality] = [];
            }
            acc[Speciality].push(rest);
            return acc;
          }, {});