Question

如何编写一个脚本，将数组的元素分组为数组（或数组对象），其中最后一个是按顺序分组的元素数组。

如果下一个元素Id是序列的一部分，它将属于prev组，否则将创建新数组，元素将落入其中。

如果元素Id高于prev元素的Id大于1 - 则是相同的序列=当前数组。

如果元素Id高于prev元素的Id大于2 - 则是下一个序列=下一个（新）数组。

如果来自各方的元素邻居Ids都超过当前的Id - 当前元素将创建一个包含其自身的数组，并且它的键将是它自己的Id。

无论结果是数组还是对象 - 生成键很容易，但组元素现在对我来说很难。

您可以尝试使用JavaScript编写，甚至可以使用Lodash库。

const data = [
{id: 1},
{id: 2},
{id: 3},
{id: 7},
{id: 9},
{id: 10},
{id: 12},
{id: 14},
{id: 15},
{id: 16}];

==========================================

const result = [
0/"1-4": [
    {id: 1},
    {id: 2},
    {id: 3},
    {id: 4}],
1/"7": [
    {id: 7}],
2/"9-10": [
    {id: 9},
    {id: 10}],
3/"12": [
    {id: 12}],
4/"14-16": [
    {id: 14},
    {id: 15},
    {id: 16}]];

Answer 1

您可以使用reduce创建一个数组数组，其中下一个预期数字是当前项目ID加一。

const data = [
  {id: 1},
  {id: 2},
  {id: 3},
  {id: 7},
  {id: 9},
  {id: 10},
  {id: 12},
  {id: 14},
  {id: 15},
  {id: 16}]
.sort((a,b)=>a.id-b.id)//make sure it is sorted by id
.reduce(
  ([result,nextNum],item)=>{//nextNum is the next expected number
    if(nextNum===undefined){//first time nextNum is undefined
      nextNum=item.id;//set nextNum to id of current item
      result.push([]);//add empty array
    }
    if(!(nextNum===item.id)){//current item id is not the expected next number
      result.push([]);//add empty array
    }
    result[result.length-1].push(item);//add item to last array of the array of arrays
    return [result,item.id+1];//next expected number is current item id + 1
  },
  [[],undefined]//initial values for result and nextNum
);
console.log(data)

Answer 2

您可以使用链式Array.reduce()调用来创建所需的结构：

＆＃13;

const data = [{"id":1},{"id":2},{"id":3},{"id":7},{"id":9},{"id":10},{"id":12},{"id":14},{"id":15},{"id":16}];

const arrayOfGroups = data
  .reduce((r, o, i) => {
    // if first or not sequence add new sub array
    if(!r.length || o.id !== data[i - 1].id + 1) r.push([]);
    
    // push to last sub array
    r[r.length - 1].push(o);
    
    return r;
  }, []);
  
const objectOfGroups = arrayOfGroups.reduce((r, a, i) => {
    const start = a[0].id;
    const end = a[a.length - 1].id;
    // if start and end are equal, add just start (to main the order of insertion, start can be just a number)
    const key = start === end ? 
      `${i}/${start}` : `${i}/${start}-${end}`;
    
    r[key] = a;
  
    return r;
  }, {});
  
console.log('arrayOfGroups', arrayOfGroups);

console.log('objectOfGroups', objectOfGroups);

＆＃13;

Answer 3

您可以通过检查结果集的最后一个数组来使用单循环方法，并检查最后一个对象的id是否在需要的范围内。

如果没有，则将新的空数组添加到结果集中。稍后将实际对象推送到最后一个数组。

var data = [{ id: 1 }, { id: 2 }, { id: 3 }, { id: 7 }, { id: 9 }, { id: 10 }, { id: 12 }, { id: 14 }, { id: 15 }, { id: 16 }],
    grouped = data.reduce((r, o) => {
        var last = r[r.length - 1];
        if (!last || last[last.length - 1].id + 1 !== o.id) {
            r.push(last = []);
        }
        last.push(o);
        return r;
    }, []);

console.log(grouped);

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

如何分组数据？

3 个答案: