Получить «диапазон» списка массивов на основе значения объекта

Question

Мой список выглядит следующим образом

[{"type":"A"},{"type":""},{"type":""},{"type":"B"},{"type":"C"},{"type":""},{"type":"A"},{"type":"A"},{"type":"D"},{"type":"C"}]

Любой пустой тип после типа считается таким.

Например: {"type":"A"},{"type":""},{"type":""} Три элемента относятся к типу A

Например: {"type":"A"},{"type":"A"} будет отображаться как диапазон 6-7 вместо 6, 7

Как я собираюсь сделать, чтобы получить диапазон (по индексу) каждого типа. Вывод, который я ищу, выглядит так:

 A: 0-2, 6-7
 B: 3
 C: 4-5, 9
 D: 8

Answer 1

Вы можете сделать:

const types = [{"type":"A"},{"type":""},{"type":""},{"type":"B"},{"type":"C"},{"type":""},{"type":"A"},{"type":"A"},{"type":"D"},{"type":"C"}]

const getStrIfCommas = (commas, c) => {
  const lastStr = commas[commas.length - 1]
  const lastStrResult = lastStr.includes('-')
    ? lastStr.replace(/\d+$/, c)
    : lastStr + `-${c}`
  return --commas.length
    ? `${commas.join(', ') || ''}, ${lastStrResult}`
    : lastStrResult
}

const getStrIfNextInt = (a, c) => {
  const commas = a.str.toString().split(', ')
  return commas.length
    ? getStrIfCommas(commas, c)
    : `${a.str}-${c}`
}

const getStrIfPrev = (a, c) => a.prev + 1 === c
  ? getStrIfNextInt(a, c)
  : a.str.length
    ? `${a.str}, ${c}`
    : ''

const result = Object
  .entries(types.reduce((a, { type }, i) => {
    if (type) {
      a[type] = a[type] || []
      a[type].push(i)
      a.prev = type
    } else if (a.prev) {
      a[a.prev].push(i)
    }
    return a
  }, {}))
  .reduce((acc, [k, indexes]) => {
    if (Array.isArray(indexes)) {
      acc[k] = indexes.reduce((a, c) => {
        a.str = a.hasOwnProperty('prev')
          ? getStrIfPrev(a, c)
          : c
        a.prev = c
        return a
      }, {})
      .str
    }
    return acc
  }, {})

console.log('Formatted result:', result)

.as-console-wrapper {
  max-height: 100% !important;
  top: 0;
}

Answer 2

Другой способ реализовать то же самое заключается в следующем:

var d =[{"type":"A"},{"type":""},{"type":""},{"type":"B"},{"type":"C"},{"type":""},{"type":"A"},{"type":"A"},{"type":"D"},{"type":"C"}];
var ranges = {}; 
d.forEach(function(item,key){
	var ind = key;
	var val = item.type;
	while(val == ""){
		ind = ind-1;
		val = d[ind].type;
	}
	if(!ranges[val]){
        ranges[val] = [];
        ranges[val].push(key);
    }
	else{
        var length = ranges[val].length;
		if( d[key-1].type == d[key].type || d[key-1].type == val){
             var splits = ranges[val][length-1].toString().split('-');		
			 ranges[val][length-1] = splits[0] +"-"+key;
        }else{
             ranges[val].push(key);
        }
    }
});
Object.keys(ranges).forEach(function(key){
console.log(key+":"+ranges[key].join(","));
})

Answer 3

Array#reduce можно использовать с условием, основанным на наличии или отсутствии значения для определенного ключа. "A" может использоваться в качестве значения по умолчанию, если type равно ""

let input = [{
  "type": "A"
}, {
  "type": ""
}, {
  "type": ""
}, {
  "type": "B"
}, {
  "type": "C"
}, {
  "type": ""
}, {
  "type": "A"
}, {
  "type": "D"
}, {
  "type": "C"
}];

let output = input.reduce((a, i, index) => {
  let key = i.type || 'A';
  a[key] ? a[key].push(index) : (a[key] = [index]);
  return a;
}, {});
console.log(output);