对数组进行排序和计数并创建两个属性，然后在每个第一个数据上显示结果

问题描述 投票：0回答：1

我有这个样本数据。

let data = [
    {BatchNumber: 1, GroupCode: 'A'},
    {BatchNumber: 1, GroupCode: 'A'},
    {BatchNumber: 1, GroupCode: 'B'},
    {BatchNumber: 1, GroupCode: 'C'},
    {BatchNumber: 1, GroupCode: 'B'},
    {BatchNumber: 1, GroupCode: 'A'},
    {BatchNumber: 2, GroupCode: 'C'},
    {BatchNumber: 2, GroupCode: 'B'},
    {BatchNumber: 2, GroupCode: 'A'},
    {BatchNumber: 2, GroupCode: 'C'}
];

我想在此数据中创建一个名为 countBatch 和 countGroup 的两个属性。

首先，我需要对数据进行排序以按升序显示它们，并对 GroupCode 的每个数据进行分组，所以我创建了这个方法：

data.sort((a, b) => {
    if (a.BatchNumber === b.BatchNumber) {
        return a.GroupCode.localeCompare(b.GroupCode);
    }
    return a.BatchNumber - b.BatchNumber;
});
const sortedGroup = {};
data.forEach((item) => {
    const key = `${item.BatchNumber}-${item.GroupCode}`;
    if (!sortedGroup[key]) {
        sortedGroup[key] = [];
    }
    sortedGroup[key].push(item);
});

现在，我将在名为 countGroup 的数据中添加属性，然后仅显示 GroupCode 中每个数组的第一个数据中的计数值，其余的应为 null 值。例如；

{BatchNumber: 1, GroupCode: 'A', countGroup: 3},
{BatchNumber: 1, GroupCode: 'A', countGroup: null},
{BatchNumber: 1, GroupCode: 'A', countGroup: null},
{BatchNumber: 1, GroupCode: 'B', countGroup: 2},
{BatchNumber: 1, GroupCode: 'B', countGroup: null},
{BatchNumber: 1, GroupCode: 'C', countGroup: 1},
{BatchNumber: 2, GroupCode: 'A', countGroup: 1},
{BatchNumber: 2, GroupCode: 'B', countGroup: 1},
{BatchNumber: 2, GroupCode: 'C', countGroup: 2},
{BatchNumber: 2, GroupCode: 'C', countGroup: null}

对于上面的结果，我创建了另一种方法：我迭代 

sortedGroup
的索引，因此我使用 
Object.keys()
函数，然后我将设置一个条件，如果索引等于 0，则会在属性上添加值（countGroup ）。否则，将该值设置为 null。 这是我创建的方法：

var result = [];
Object.keys(sortedGroup).forEach((key) => {
    const group = sortedGroup[key];
    group.forEach((data, index) => {
        if (index === 0) {
            data.countGroup = group.length;
        } else {
            data.countGroup = null;
        }
        result.push(data);
    });
});

执行上面的代码，我现在可以获得我想要的结果。 这是一个演示。

let data = [
    {BatchNumber: 1, GroupCode: 'A'},
    {BatchNumber: 1, GroupCode: 'A'},
    {BatchNumber: 1, GroupCode: 'B'},
    {BatchNumber: 1, GroupCode: 'C'},
    {BatchNumber: 1, GroupCode: 'B'},
    {BatchNumber: 1, GroupCode: 'A'},
    {BatchNumber: 2, GroupCode: 'C'},
    {BatchNumber: 2, GroupCode: 'B'},
    {BatchNumber: 2, GroupCode: 'A'},
    {BatchNumber: 2, GroupCode: 'C'}
];
data.sort((a, b) => {
    if (a.BatchNumber === b.BatchNumber) {
        return a.GroupCode.localeCompare(b.GroupCode);
    }
    return a.BatchNumber - b.BatchNumber;
});
const sortedGroup = {};
data.forEach((item) => {
    const key = `${item.BatchNumber}-${item.GroupCode}`;
    if (!sortedGroup[key]) {
        sortedGroup[key] = [];
    }
    sortedGroup[key].push(item);
});
var result = [];
Object.keys(sortedGroup).forEach((key) => {
    const group = sortedGroup[key];
    group.forEach((data, index) => {
        if (index === 0) {
            data.countGroup = group.length;
        } else {
            data.countGroup = null;
        }
        result.push(data);
    });
});
console.log(result);

最后，我将在数据中添加名为 countBatch 的属性。由于该值将对批次进行计数，因此我创建了一个变量和一个对批次进行计数的方法：这是我使用的方法：

const batchCounts = {};
data.forEach((item) => {
    if (!batchCounts[item.BatchNumber]) {
        batchCounts[item.BatchNumber] = 0;
    }
    batchCounts[item.BatchNumber]++;
});

然后，将

batchCounts
的结果添加到
sortedGroup
的迭代中。我添加了名为 
batchCount
的变量，其值为 
batchCounts[group[0].BatchNumber]
。这显示了 BatchNunber 的计数值，并通过执行 
data.countBatch = batchCount;

将其传递给组的迭代

问题是；每次插入 countGroup 值时，都会插入 countBatch 的值。我只想将 countBatch 的值插入到每个批次号的第一个数据中。

当前

let data = [
    {BatchNumber: 1, GroupCode: 'A'},
    {BatchNumber: 1, GroupCode: 'A'},
    {BatchNumber: 1, GroupCode: 'B'},
    {BatchNumber: 1, GroupCode: 'C'},
    {BatchNumber: 1, GroupCode: 'B'},
    {BatchNumber: 1, GroupCode: 'A'},
    {BatchNumber: 2, GroupCode: 'C'},
    {BatchNumber: 2, GroupCode: 'B'},
    {BatchNumber: 2, GroupCode: 'A'},
    {BatchNumber: 2, GroupCode: 'C'}
];


data.sort((a, b) => {
    if (a.BatchNumber === b.BatchNumber) {
        return a.GroupCode.localeCompare(b.GroupCode);
    }
    return a.BatchNumber - b.BatchNumber;
});
const sortedGroup = {};
data.forEach((item) => {
    const key = `${item.BatchNumber}-${item.GroupCode}`;
    if (!sortedGroup[key]) {
        sortedGroup[key] = [];
    }
    sortedGroup[key].push(item);
});
const batchCounts = {};
data.forEach((item) => {
    if (!batchCounts[item.BatchNumber]) {
        batchCounts[item.BatchNumber] = 0;
    }
    batchCounts[item.BatchNumber]++;
});
var result = [];
Object.keys(sortedGroup).forEach((key) => {
    const group = sortedGroup[key];
    const batchCount = batchCounts[group[0].BatchNumber];
    group.forEach((data, index) => {
        if (index === 0) {
            data.countBatch = batchCount;
            data.countGroup = group.length;
        } else {
            data.countBatch = null;
            data.countGroup = null;
        }
        result.push(data);
    });
});
console.log(result);

预期

let expected = [
    {BatchNumber: 1, GroupCode: 'A', countBatch: 6, countGroup: 3},
    {BatchNumber: 1, GroupCode: 'A', countBatch: null, countGroup: null},
    {BatchNumber: 1, GroupCode: 'A', countBatch: null, countGroup: null},
    {BatchNumber: 1, GroupCode: 'B', countBatch: null, countGroup: 2},
    {BatchNumber: 1, GroupCode: 'B', countBatch: null, countGroup: null},
    {BatchNumber: 1, GroupCode: 'C', countBatch: null, countGroup: 1},
    {BatchNumber: 2, GroupCode: 'A', countBatch: 4, countGroup: 1},
    {BatchNumber: 2, GroupCode: 'B', countBatch: null, countGroup: 1},
    {BatchNumber: 2, GroupCode: 'C', countBatch: null, countGroup: 2},
    {BatchNumber: 2, GroupCode: 'C', countBatch: null, countGroup: null}
];
console.log(expected);

javascript arrays sorting object
1个回答
0
投票

您可以对现有代码进行的最简单的修改是从 

delete
对象中获取当前批次编号，然后仅在从 
batchCounts
对象中获取编号时添加 
batchCount
：




batchCounts








顺便说一句，我建议您考虑将密钥存储在 ES6 映射中，以便当您迭代密钥时，它们在所有环境中都按预期顺序出现。您还可以在构建 
let data = [
    {BatchNumber: 1, GroupCode: 'A'},
    {BatchNumber: 1, GroupCode: 'A'},
    {BatchNumber: 1, GroupCode: 'B'},
    {BatchNumber: 1, GroupCode: 'C'},
    {BatchNumber: 1, GroupCode: 'B'},
    {BatchNumber: 1, GroupCode: 'A'},
    {BatchNumber: 2, GroupCode: 'C'},
    {BatchNumber: 2, GroupCode: 'B'},
    {BatchNumber: 2, GroupCode: 'A'},
    {BatchNumber: 2, GroupCode: 'C'}
];


data.sort((a, b) => {
    if (a.BatchNumber === b.BatchNumber) {
        return a.GroupCode.localeCompare(b.GroupCode);
    }
    return a.BatchNumber - b.BatchNumber;
});
const sortedGroup = {};
data.forEach((item) => {
    const key = `${item.BatchNumber}-${item.GroupCode}`;
    if (!sortedGroup[key]) {
        sortedGroup[key] = [];
    }
    sortedGroup[key].push(item);
});
const batchCounts = {};
data.forEach((item) => {
    if (!batchCounts[item.BatchNumber]) {
        batchCounts[item.BatchNumber] = 0;
    }
    batchCounts[item.BatchNumber]++;
});
var result = [];
Object.keys(sortedGroup).forEach((key) => {
    const group = sortedGroup[key];
    group.forEach((data, index) => {
        const batchCount = batchCounts[group[0].BatchNumber];    
        if(batchCount != undefined) {
          delete batchCounts[group[0].BatchNumber];
          data.countBatch = batchCount;
        } else {
          data.countBatch = null;
        }
        
    
        if (index === 0) {
            data.countGroup = group.length;
        } else {
            data.countGroup = null;
        }
        result.push(data);
    });
});
console.log(result);
 对象时构建 
batchCounts
 以避免额外的迭代，例如：
sortedGroup

    

      

      
    

  

  

    
最新问题


  





  

    © www.soinside.com 2019 - 2024. All rights reserved.