Teniendo en cuenta que tengo la matriz:

var arr = [
   {type:'a', name:'a1'}, {type:'b', name:'b1'}, {type:'hr'}, 
   {type:'a', name:'a2'}, {type:'b', name:'b2'}, {type:'hr'}, 
   {type:'a', name:'a3'}, {type:'b', name:'b2'}, {type:'hr'} 
]

Lo dividiría en una matriz de matrices de objetos usando el objeto {type:'hr'} como elemento separador. Entonces el resultado es:

[
[{type:'a', name:'a1'}, {type:'b', name:'b1'}],
[{type:'a', name:'a3'}, {type:'b', name:'b2'}],
[{type:'a', name:'a3'}, {type:'b', name:'b3'}]
]

¿Crees que lodash es útil para ello?

Actualmente he usado _.map para esto:

 var result = [], sub = [];                                                                                                                                    _.map(tokens, (it, idx) => {                                                                                                                                      if(it.type === 'hr'){                                                     
        result.push(sub);                                                 
                sub = [];                                                 
            } else {                                                      
                sub.push(it);                                             
            }                                                             
        });                                                               
        if(sub.length){                                                   
            result.push(sub);                                             
        }                                                                 
    console.log(result);  
1
Archer 1 sep. 2016 a las 16:09

2 respuestas

La mejor respuesta

Puede usar reducir y crear una nueva submatriz cuando encuentre {type:'hr'} :

var arr = [
   {type:'a', name:'a1'}, {type:'b', name:'b1'}, {type:'hr'}, 
   {type:'a', name:'a2'}, {type:'b', name:'b2'}, {type:'hr'}, 
   {type:'a', name:'a3'}, {type:'b', name:'b2'}, {type:'hr'} 
];
var delimiter = { type: 'hr' };
var res = _.reduce(arr, function(result, obj, index) {
  if (_.isEqual(obj, delimiter)) {
    if (index !== arr.length - 1) result.push([]);
  } else {
    _.last(result).push(obj);
  }
  return result;
}, [[]]);

console.log(res);
<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.15.0/lodash.min.js"></script>
2
Tholle 1 sep. 2016 a las 16:35

Esto es lo que haría:

function splitBy(array, predicate, result = []) {
  const taken = _.takeWhile(array, predicate);
  const remaining = _.tail(_.dropWhile(array, predicate));

  return remaining.length ?
    splitBy(remaining, predicate, result.concat([taken])) :
    result.concat([taken]);
}

splitBy(
  arr,
  _.negate(_.partial(_.isEqual, { type: 'hr' })))
);

La idea es usar takeWhile () para obtener los elementos que no coinciden con el separador . Luego, dropWhile () crea el siguiente fragmento de matriz para iterar pasándolo a { {X0}}.

El predicado real que se usa para determinar qué es el separador se pasa como argumento, lo que significa que puede reutilizar esta función para otros tipos de separadores.

1
Adam Boduch 1 sep. 2016 a las 18:54