Biorąc pod uwagę tablicę jako

[
    {name: 'John', span: 1},
    {name: 'John', span: 1},
    {name: 'Peter', span: 1},
    {name: 'John', span: 1},
    {name: 'Peter', span: 1},
    {name: 'Peter', span: 1},
    {name: 'Peter', span: 1}
]

Chciałbym scalić go w taki sposób, że jeśli się powracają, połączamy i podsumowujemy nieruchomość {x0}}. Więc oczekiwany wyjście jest

[
    {name: 'John', span: 2},
    {name: 'Peter', span: 1},
    {name: 'John', span: 1},
    {name: 'Peter', span: 3}
]

Czy ktoś może zasugerować odpowiedni sposób, aby to zrobić? Najlepsze, z którym mogłem się wymyślić

var data = [
    {name: 'John', span: 1},
    {name: 'John', span: 1},
    {name: 'Peter', span: 1},
    {name: 'John', span: 1},
    {name: 'Peter', span: 1},
    {name: 'Peter', span: 1},
    {name: 'Peter', span: 1}
];
var result = [];

var count = 0;
while (count <= data.length) {
    var datum = data[count];
    var isFound = false;

    do {
        var nextCount = data[++count];

        if (!nextCount) {
            break;
        }

        if (nextCount.name === datum.name) {
            datum.span += 1;
            isFound = true;
        } else {
            isFound = false;
        }
    } while(isFound);   

    result.push(datum);
}

console.log(result);

To działa, zapisz dla undefined, który jest umieszczony na końcu (nie wiem dlaczego). Czy ktoś może zasugerować bardziej skuteczny i czytelny sposób, aby to zrobić?

0
cr05s19xx 4 czerwiec 2018, 13:02

3 odpowiedzi

Najlepsza odpowiedź

Możesz filtrować i zaktualizować obiekt podczas sprawdzania ostatniego obiektu.

To rozwiązanie zamuwia oryginalną tablicę.

var array = [{ name: 'John', span: 1 }, { name: 'John', span: 1 }, { name: 'Peter', span: 1 }, { name: 'John', span: 1 }, { name: 'Peter', span: 1 }, { name: 'Peter', span: 1 }, { name: 'Peter', span: 1 }],
    result = array.filter((last => o => {
        if (!last || last.name !== o.name) {
            last = o;
            return true;
        }
        last.span += o.span;
    })());

console.log(result);
.as-console-wrapper { max-height: 100% !important; top: 0; }
1
Nina Scholz 4 czerwiec 2018, 10:54

To mogłoby być rozwiązanie

const arr = [
  {name: 'John', span: 1},
  {name: 'John', span: 1},
  {name: 'Peter', span: 1},
  {name: 'John', span: 1},
  {name: 'Peter', span: 1},
  {name: 'Peter', span: 1},
  {name: 'Peter', span: 1}
]

const parsed = arr.reduce((acc, item) => {
  if(acc[acc.length - 1] && acc[acc.length - 1].name == item.name) {
    acc[acc.length - 1].span++
  } else {
    acc.push(item)
  }
  return acc
}, [])

console.log(parsed)
1
Olivier Krull 4 czerwiec 2018, 10:31

Co powiesz na coś takiego:

var data = [
    {name: 'John', span: 1},
    {name: 'John', span: 1},
    {name: 'Peter', span: 1},
    {name: 'John', span: 1},
    {name: 'Peter', span: 1},
    {name: 'Peter', span: 1},
    {name: 'Peter', span: 1}
];

function groupSpans(data) {
    const result = [];
    let current;
    let currentKey;
    data.forEach((datum) => {
        if(datum.name !== currentKey) {
            currentKey = datum.name;
            current = {... datum};
            result.push(current);
            return;
        }
        current.span++;
    });
    return result;
}

console.log(groupSpans(data));

- >.

~/Desktop $ node so50677991.js
[ { name: 'John', span: 2 },
  { name: 'Peter', span: 1 },
  { name: 'John', span: 1 },
  { name: 'Peter', span: 3 } ]
1
AKX 4 czerwiec 2018, 10:09