сравнить текущее повторное значение с предыдущим повторенным значением

Question

У меня есть этот массив объектов, я хочу построить из него строку.

 [
   {
     "parent": "mcd",
     "child": "coke"
   },
   {
     "parent": "mcd",
     "child": "burger"
   },
   {
     "parent": "kfc",
     "child": "chicken"
   }
 ]

Как я могу произвести это?

mcd_coke_burger-kfc_chicken

Answer 1

Сначала сгруппируйте значения соответственно - затем просто объедините значения:

const data = [{"parent":"mcd","child":"coke"},{"parent":"mcd","child":"burger"},{"parent":"kfc","child":"chicken"}];
const res = Object.entries(data.reduce((acc, { parent, child }) => {
  acc[parent] = acc[parent] || [];
  acc[parent].push(child);
  return acc;
}, {})).map(([k, v]) => `${k}-${v.join("_")}`).join("_");
console.log(res);

Answer 2

Сгруппируйте элементы, затем объедините группы:

const order = [{
    "parent": "mcd",
    "child": "coke"
  },
  {
    "parent": "mcd",
    "child": "burger"
  },
  {
    "parent": "kfc",
    "child": "chicken"
  }
];

const grouped = order.reduce((grouped, item) => {
  grouped[item.parent] = grouped[item.parent] || [];
  grouped[item.parent].push(item.child);
  return grouped;
}, {});

const result = Object.keys(grouped)
    .map(key => `${key}_${grouped[key].join('_')}`)
    .join('-');

console.log(result);

Answer 3

Если у вас есть правильно отсортированный массив.

const items = [
    {
        "parent": "mcd",
        "child": "coke"
    },
    {
        "parent": "mcd",
        "child": "burger"
    },
    {
        "parent": "kfc",
        "child": "chicken"
    }
];

let currentParent;
let string = '';
items.forEach((item, i) => {
    if (item.parent !== currentParent) {
        currentParent = item.parent;
        string += (i ? '-' : '') + currentParent;
    }
    string += '_' + item.child;
});
console.log(string);

Answer 4

Вы можете попробовать вот так:

const data = [
   {
     "parent": "mcd",
     "child": "coke"
   },
   {
     "parent": "mcd",
     "child": "burger"
   },
   {
     "parent": "kfc",
     "child": "chicken"
   }
];

// Group by 'parent' property
const groupedParent = data.reduce((acc, curr) => {
  if(!acc[curr.parent]) 
	acc[curr.parent] = [];
  
  acc[curr.parent].push(curr);
  return acc;
}, {});

// Now do join on the entries
const res = Object.entries(groupedParent)
                  .map(x => `${x[0]}_${x[1].map(y => y.child).join('_')}`)
                  .join('-');

console.log(res);

Answer 5

Мой подход к вашему вопросу будет следующим:

1) Сгруппировать массив объектов по свойству parent. В результате вы получите объект пар ключ-значение со значениями parent в качестве ключа.

2) Выполните итерацию по объекту и сформируйте новую строку, добавив значения каждого child к соответствующему родительскому элементу.

const arr = [{
    "parent": "mcd",
    "child": "coke"
  },
  {
    "parent": "mcd",
    "child": "burger"
  },
  {
    "parent": "kfc",
    "child": "chicken"
  }
]

const grouped = arr.reduce((h, obj) => Object.assign(h, {
  [obj['parent']]: (h[obj['parent']] || []).concat(obj)
}), {});

let result = '';
let index = 0;

for (let key in grouped) {
  if (index !== 0) {
    result += '-'
  }
  result += 'key';
  grouped[key].map(obj => {
    result += `_${obj.child}`;
  });
  index++;
}
console.log(result);

Answer 6

Здесь я использовал pGroup, чтобы увидеть, есть ли у некоторых детей одинаковые родители:

let items = [
   {
     "parent": "mcd",
     "child": "coke"
   },
   {
     "parent": "mcd",
     "child": "burger"
   },
   {
     "parent": "kfc",
     "child": "chicken"
   }
 ];
var str = '';
var pGroup = [];
for (i=0; i<items.length; i++){
  if (pGroup.includes(items[i].parent)) {
    str += '_' + items[i].child;
  }
  else {
    pGroup.push(items[i].parent);
    if (i != 0) {
      str += '-';
    }
    str += items[i].parent + '_' + items[i].child;
  }
}
console.log(str);