2

这是我的数组：

    myArray = [
        {group: "one", version: 1.1, old: 0.1},
        {group: "two", version: 2.1, old: 1.1},
        {group: "one", version: 1.2, old: 0.2},
        {group: "one", version: 1.3, old: 0.3}
    ]

我想转换成这个（只需要检索更大和更小的版本）：

myArray = [
 {group: "one", recentVersion: 1.3, oldVersion:0.1 }
 {group: "two", recentVersion: 2.1, oldVersion:1.1}
 ]

我正在尝试什么：

const groups = {};
    for (let i = 0; i < myArray.length; i++) {
        const groupName = diffList[i].group;
        if (!groups[groupName]) {
            groups[groupName] = [];
        }
        groups[groupName].push(diffList[i].version);
    }
    const myArray = [];
    for (const groupName in groups) {
        myArray.push({ group: groupName, recentVersion: groups[groupName});
    }
    console.log(myArray);

实际结果 ：

myArray = [
 {group: "one", recentVersion: [1.1,1.2,1.3]}
 {group: "two", recentVersion: [2.2]}
 ]

我不知道如何检索更大和更小的版本以及如何推送 oldVersion ......

4

5 回答 5

0

复制示例

此示例首先按组名聚合所有版本，然后将版本从旧到新排序，并返回具有最新和最旧对象属性的数组。

myArray = myArray
.reduce((_myArray, arrayItem) => {
  _myArray[arrayItem.group] = _myArray[arrayItem.group] || []
  _myArray[arrayItem.group].push(arrayItem.version, arrayItem.old)
  return _myArray
}, {})
myArray = Object.entries(myArray)
.reduce((_myArray, [groupName, groupVersions]) => {
  groupVersions = groupVersions
  .sort((current, next) => current > next ? -1 : 1)
  _myArray.push({
    group: groupName,
    recentVersion: groupVersions[0],
    oldVersion: groupVersions[groupVersions.length - 1],
  })
  return _myArray
}, [])
于 2020-03-05T15:46:48.397 回答
0

如有必要，您可以对数据进行分组并更新版本。

var data = [{ group: "one", version: 1.1, old: 0.1 }, { group: "two", version: 2.1, old: 1.1 }, { group: "one", version: 1.2, old: 0.2 }, { group: "one", version: 1.3, old: 0.3 }],
    grouped = Object.values(data.reduce((r, { group, version, old }) => {
        if (!r[group]) {
            r[group] = { group, recentVersion: version, oldVersion: old };
            return r;
        }
        if (r[group].recentVersion < version) r[group].recentVersion = version;
        if (r[group].oldVersion > old) r[group].oldVersion = old;
        return r;
    }, {}));
    
console.log(grouped);
.as-console-wrapper { max-height: 100% !important; top: 0; }

于 2020-03-05T15:47:06.210 回答
0

我已经编辑了您编写的代码，并合并了完成所需任务所需的更改。请在下面找到代码：

myArray = [{
    group: "one",
    version: 1.1,
    old: 0.1
  },
  {
    group: "two",
    version: 2.1,
    old: 1.1
  },
  {
    group: "one",
    version: 1.2,
    old: 0.2
  },
  {
    group: "one",
    version: 1.3,
    old: 0.3
  }
]

const group = {};
const results = [];
for (let i = 0; i < myArray.length; i++) {
  const element = myArray[i];
  if (!group[element.group]) {
    group[element.group] = true;
    results.push({
      group: element.group,
      recentVersion: element.version,
      oldVersion: element.old
    })
  } else {
    const index = results.findIndex((d) => d.group === element.group);
    if (element.version > results[index].recentVersion) {
      results[index].recentVersion = element.version;
    }
    if (element.old < results[index].oldVersion) {
      results[index].oldVersion = element.old;
    }
  }
}

console.log(results);

于 2020-03-05T16:29:27.003 回答
0

您可以使用Array#reduce. 我喜欢使用地图按名称查找组，而不是重复搜索数组。您可以使用Math.minandMath.max来设置正确的recentVersionand oldVersion。

const myArray = [
        {group: "one", version: 1.1, old: 0.1},
        {group: "two", version: 2.1, old: 1.1},
        {group: "one", version: 1.2, old: 0.2},
        {group: "one", version: 1.3, old: 0.3}
    ];

const result = myArray.reduce((acc,{group,version,old}) => {
  let cur = acc[0][group];
  if(!cur) acc.push(cur = acc[0][group] = {group});
  cur.recentVersion = Math.max(version, cur.recentVersion || version);
  cur.oldVersion = Math.min(old, cur.oldVersion || old);
  return acc;
}, [{}]).slice(1);

console.log(result);

于 2020-03-05T15:51:19.947 回答
0

您可以通过在第一个 for 循环中进行比较来设置旧版本和最新版本

let diffList = [
  { group: "one", version: 1.1, old: 0.1 },
  { group: "two", version: 2.1, old: 1.1 },
  { group: "one", version: 1.2, old: 0.2 },
  { group: "one", version: 1.3, old: 0.3 }
];
const groups = {};
for (let i = 0; i < diffList.length; i++) {
  const groupName = diffList[i].group;
  if (!groups[groupName]) {
    groups[groupName] = {
      recentVersion: diffList[i].version,
      oldVersion: diffList[i].old
    };
  }
  if (groups[groupName].recentVersion < diffList[i].version) {
    groups[groupName].recentVersion = diffList[i].version;
  }
  if (groups[groupName].oldVersion > diffList[i].old) {
    groups[groupName].oldVersion = diffList[i].version;
  }
}
let myArray = [];
for (const groupName in groups) {
  myArray.push({
    group: groupName,
    recentVersion: groups[groupName].recentVersion,
    oldVersion: groups[groupName].oldVersion
  });
}
console.log(myArray);

于 2020-03-05T15:52:12.293 回答