Início / coding / Perguntas / 78031048
Accepted
Keyboard Corporation
Asked: 2024-02-21 08:58:05 +0800 CST

Classifique e conte a matriz e crie duas propriedades e exiba o resultado em cada primeiro dado

  • 772

Eu tenho esses dados de amostra.

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'}
];

Quero criar duas propriedades nesses dados chamadas countBatch e countGroup .

Primeiro, preciso classificar os dados para mostrá-los em ordem crescente e agrupar cada dado do GroupCode, então crio este método:

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);
});

Agora, adicionarei a propriedade nos dados chamados countGroup e, em seguida, mostrarei apenas o valor contado nos primeiros dados do array, cada um do GroupCode, o restante deve estar em valor nulo . Por exemplo;

{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}

Para o resultado acima eu crio outro método: eu itero sobre o índice de sortedGroupentão uso Object.keys()a função e então farei uma condição que se o índice for igual a 0, ele agrega valor na propriedade ( countGroup ). Caso contrário, torne o valor null . Aqui está o método que criei:

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);
    });
});

Fazendo o código acima, agora posso obter o resultado que desejo. Aqui está uma demonstração.

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);

Por último, adicionarei a propriedade chamada countBatch nos dados. Como o valor contará o lote, crio uma variável e um método que conta o lote: Aqui está o método que usei:

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

E então, adicione o resultado batchCountsdentro da iteração de sortedGroup. Eu adiciono uma variável chamada batchCountcom valor de batchCounts[group[0].BatchNumber]. Isso mostra o valor de contagem de BatchNunber e apenas passa para a iteração do grupo fazendodata.countBatch = batchCount;

O problema é; o valor de countBatch é inserido sempre que o valor countGroup é inserido. Quero apenas inserir o valor de countBatch nos primeiros dados de cada número de lote.

ATUAL

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);

ESPERADO

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

3 respostas

  1. Best Answer

    A modificação mais simples que você provavelmente pode fazer em seu código existente é deleteo número do lote atual do seu batchCountsobjeto e, em seguida, adicionar apenas batchCountse você obtiver um número do seu batchCountsobjeto:

    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);

    Por outro lado, sugiro que você armazene suas chaves em um mapa ES6 para que, quando você iterar as chaves, elas apareçam na ordem esperada em todos os ambientes. Você também pode construir batchCountsà medida que constrói sortedGroupo objeto para evitar uma iteração adicional, por exemplo:

    const sortedGroup = {};
const batchCounts = {};
data.forEach((item) => {
    const key = `${item.BatchNumber}-${item.GroupCode}`;
    batchCounts[item.BatchNumber] = (batchCounts[item.BatchNumber] || 0) + 1;
    if (!sortedGroup[key]) {
        sortedGroup[key] = [];
    }
    sortedGroup[key].push(item);
});
    • 1

  2. Apenas para obter informações adicionais. Isso pode ser feito usando Object.groupByquando for amplamente suportado .

    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;
});

// defines what attribute needs to be added based on keys
const attributes = {
  countGroup: ['BatchNumber', 'GroupCode'],
  countBatch: ['BatchNumber']
}

Object.entries(attributes).forEach(([key, identifiers]) => {
  Object.values(Object.groupBy(data, item => identifiers.map(id => item[id]).join())).forEach(group => {
    group.forEach((item, i) => item[key] = i ? null : group.length);
  });
});

console.log(data);

    • 1

  3. Resolvo o problema adicionando uma propriedade temporária no objeto de dados. Chame essa propriedade dentro da groupiteração e defina o valor de countBatch e, em seguida, exclua a propriedade temporária. Obrigado a @Nick Parsons que me deu uma dica. Eu ainda aceito sua resposta.

    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, index) => {
    item.tempBatchCount = batchCounts[item.BatchNumber] //added this line;
    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) => {
        data.countBatch = !(data.tempBatchCount) ? batchCount : null; //added this line;
        delete data.tempBatchCount; //added this line;
        if (index === 0) {
            data.countGroup = group.length;
        } else {
            data.countGroup = null;
        }
        result.push(data);
    });
});
console.log(result);

    • 0

relate perguntas