Javascript 按间隔对对象数组进行分组

我试图通过包含在2个数字范围内的对象的两个属性（在本例中为start和start+2之间）对我的JavaScript对象数组进行分组，这意味着每2秒一次，然后将内容集中到一个数组中

var myArray = [
{
    start: 1.1,
    end: 1.6,
    content: "you"
},
{
    start: 1.8,
    end: 2.1,
    content: "should"
},
{
    start: 2.2,
    end: 2.5,
    content: "not"
},
{
    start: 2.9,
    end: 3.1,
    content: "be"
},
{
    start: 3.6,
    end: 4.0,
    content: "here"
},
{
    start: 4.5,
    end: 5.0,
    content: "please"
},
{
    start: 5.2,
    end: 5.8,
    content: "go"
},
{
    start: 5.9,
    end: 6.3,
    content: "away"
}
];

想法是尝试得到这个，注意最大间隔在2秒之间

var final = [
    {
        startArray: [1.1, 1.8, 2.2, 2.9],
        endArray: [1.6, 2.1, 2.5, 3.1],
        start: 1.1,
        end: 3.1,
        content: ["you", "should", "not", "be"]
    },
    {
        startArray: [3.6, 4.5],
        endArray: [4.0, 5.0],
        start: 3.6,
        end: 5.0,
        content: ["here","please"]
    },
    {
        startArray: [5.2, 5.9],
        endArray: [5.8, 6.3],
        start: 5.2,
        end: 6.3,
        content: ["go","away"]
    }
];    

---

我应该如何处理这个问题？帮助：（！。

您可以使用Array.prototype.reduce在现有阵列上迭代并构建新阵列。类似如下：

let final = myArray.reduce((acc, item) => {
  let oldItem = acc.find(accItem => {
    // check if accItem is within two seconds of item
  });
  if (oldItem) {
    oldItem.startArray.push(item.start);
    // ... rest of the properties
  }
  else {
    return acc.concat({
      startArray: [item.start],
      endArray: [item.end],
      start: item.start,
      end: item.end,
      content: [item.content]
    });
  }
}, []);

---

您可以使用Array.prototype.reduce在现有阵列上迭代并构建新阵列。如下所示：

let final = myArray.reduce((acc, item) => {
  let oldItem = acc.find(accItem => {
    // check if accItem is within two seconds of item
  });
  if (oldItem) {
    oldItem.startArray.push(item.start);
    // ... rest of the properties
  }
  else {
    return acc.concat({
      startArray: [item.start],
      endArray: [item.end],
      start: item.start,
      end: item.end,
      content: [item.content]
    });
  }
}, []);

---

基本代码如下，无高级内容：

var final = [];
var j = 0;
for (var i = 0; i < myArray.length;) {
  var startArray = [];
  var endArray = [];
  var content = [];
  var start = myArray[j].start;
  var end = myArray[j].end;
  while ( i < myArray.length && (myArray[i].end - myArray[j].start) <= 2) {
    startArray[startArray.length] = myArray[i].start;
    endArray[endArray.length] = myArray[i].end;
    content[content.length] = myArray[i].content;
    end = myArray[i].end;

    i++;
  }
  final[final.length] = {
    startArray : startArray,
    endArray : endArray,
    start : start,
    end : end,
    content : content
  };

  j = i;
}
console.log(final);

var final=[]；
var j=0；
对于（var i=0；i而（i
var final = [];
var j = 0;
for (var i = 0; i < myArray.length;) {
  var startArray = [];
  var endArray = [];
  var content = [];
  var start = myArray[j].start;
  var end = myArray[j].end;
  while ( i < myArray.length && (myArray[i].end - myArray[j].start) <= 2) {
    startArray[startArray.length] = myArray[i].start;
    endArray[endArray.length] = myArray[i].end;
    content[content.length] = myArray[i].content;
    end = myArray[i].end;

    i++;
  }
  final[final.length] = {
    startArray : startArray,
    endArray : endArray,
    start : start,
    end : end,
    content : content
  };

  j = i;
}
console.log(final);

var final=[]；
var j=0；
对于（var i=0；i而（i
var myArray = [
{
    start: 1.1,
    end: 1.6,
    content: "you"
},
{
    start: 1.8,
    end: 2.1,
    content: "should"
},
{
    start: 2.2,
    end: 2.5,
    content: "not"
},
{
    start: 2.9,
    end: 3.1,
    content: "be"
},
{
    start: 3.6,
    end: 4.0,
    content: "here"
},
{
    start: 4.5,
    end: 5.0,
    content: "please"
},
{
    start: 5.2,
    end: 5.8,
    content: "go"
},
{
    start: 5.9,
    end: 6.3,
    content: "away"
}
];
var final = [];
function groupValues(t, v, i, a) {
    print("item " + i);
    if (t.hasOwnProperty('start') && v.end <= t.start + 2) { 
        t.startArray.push(v.start); 
        t.endArray.push(v.end); 
        t.end = v.end; 
        t.content.push(v.content);
    }
    else {
        if (t.hasOwnProperty('start')) final.push(t);
        t = { startArray: [v.start],
             endArray: [v.end],
             start: v.start,
             end: v.end,
             content: [v.content]
            };
    }
    if (i == a.length - 1) final.push(t);
    return t;
}
myArray.reduce(groupValues, {});
console.log(final);

使用Array.reduce是一种方法：

var myArray = [
{
    start: 1.1,
    end: 1.6,
    content: "you"
},
{
    start: 1.8,
    end: 2.1,
    content: "should"
},
{
    start: 2.2,
    end: 2.5,
    content: "not"
},
{
    start: 2.9,
    end: 3.1,
    content: "be"
},
{
    start: 3.6,
    end: 4.0,
    content: "here"
},
{
    start: 4.5,
    end: 5.0,
    content: "please"
},
{
    start: 5.2,
    end: 5.8,
    content: "go"
},
{
    start: 5.9,
    end: 6.3,
    content: "away"
}
];
var final = [];
function groupValues(t, v, i, a) {
    print("item " + i);
    if (t.hasOwnProperty('start') && v.end <= t.start + 2) { 
        t.startArray.push(v.start); 
        t.endArray.push(v.end); 
        t.end = v.end; 
        t.content.push(v.content);
    }
    else {
        if (t.hasOwnProperty('start')) final.push(t);
        t = { startArray: [v.start],
             endArray: [v.end],
             start: v.start,
             end: v.end,
             content: [v.content]
            };
    }
    if (i == a.length - 1) final.push(t);
    return t;
}
myArray.reduce(groupValues, {});
console.log(final);

如果首先对数组进行排序，则只需遍历数组并将相邻元素分组：

 function groupConsecutive(array, delay = 2) {
    array.sort((a, b) => a.start - b.start);

   let prev = { end: -Infinity }, current;
   const result = [];

   for(const {start, end, content } of array) {
     if(prev.end + delay >= start) {
       // Group
       current.content.push(content);
       current.startArray.push(start);
       current.endArray.push(end);
       current.start = Math.min(current.start, start);
       current.end = Math.max(current.end, end);
     } else {
       result.push(current = {
         startArray: [start],
         endArray: [end],
         content: [content],
         start,
         end,
      });
     }
   }

   return result;
 }

如果首先对数组进行排序，则只需遍历数组并将相邻元素分组：

 function groupConsecutive(array, delay = 2) {
    array.sort((a, b) => a.start - b.start);

   let prev = { end: -Infinity }, current;
   const result = [];

   for(const {start, end, content } of array) {
     if(prev.end + delay >= start) {
       // Group
       current.content.push(content);
       current.startArray.push(start);
       current.endArray.push(end);
       current.start = Math.min(current.start, start);
       current.end = Math.max(current.end, end);
     } else {
       result.push(current = {
         startArray: [start],
         endArray: [end],
         content: [content],
         start,
         end,
      });
     }
   }

   return result;
 }

假设数组已排序，则可以使用


let myArray=[{start:1.1，end:1.6，content:“你”}，{start:1.8，end:2.1，content:“应该”}，{start:2.2，end:2.5，content:“不”}，{start:2.9，end:3.1，content:“是”}，{start:3.6，end:4.0，content:“在这里”}，{start:4.5，end:5.0，content:“请”}，{start:5.2，end:5.8，content:{start:5，start:3，content:{；
让obj；
让final=myArray.reduce（（a，{start，end，content}，i）=>{
/*在第一个元素的情况下，对于
*在前面的组中，obj将是未定义的，因此将对其进行初始化*/
如果（！obj）{
obj={start，end，startArray:[start]，endArray:[end]，content:[content]}；
}否则{
让diff=end-obj.start；//计算差值
//如果差值小于或等于2，请将对象添加到组中
如果（diff假设数组已排序，则可以使用


let myArray=[{start:1.1，end:1.6，content:“你”}，{start:1.8，end:2.1，content:“应该”}，{start:2.2，end:2.5，content:“不”}，{start:2.9，end:3.1，content:“是”}，{start:3.6，end:4.0，content:“在这里”}，{start:4.5，end:5.0，content:“请”}，{start:5.2，end:5.8，content:{start:5，start:3，content:{；
让obj；
让final=myArray.reduce（（a，{start，end，content}，i）=>{
/*在第一个元素的情况下，对于
*在前面的组中，obj将是未定义的，因此将对其进行初始化*/
如果（！obj）{
obj={start，end，startArray:[start]，endArray:[end]，content:[content]}；
}否则{
让diff=end-obj.start；//计算差值
//如果差值小于或等于2，请将对象添加到组中
如果（diff）你自己有没有尝试过解决这个问题？请发布你尝试过的代码，谢谢@t.niese，我会尝试第二个，我在尝试创建间隔时遇到了问题。当你说“最大间隔在2秒之间”时你指的是哪两个值？
start
组中第一个元素的值和
end
组中最后一个元素的值？是的@Nick
start
和
end
就像时间指示器你自己有没有尝试过解决这个问题？请发布你尝试过的代码，谢谢@t.niese，我会尝试第二个，我在尝试创建间隔时遇到了问题。当你说“最大间隔在2秒之间”时，你指的是哪两个值？
start
（组中第一个元素）和
end
（最后一个元素）？Yes@Nick
start
和
end
类似于时间指示器