Javascript 在具有特定规则的事件数组中插入事件

我有一个特定日期的事件列表。（事件时间是一个力矩对象）

我需要在此数组中添加一个事件，以便新事件时间不少于上午5点，至少在前一个事件（如果有）后3小时，在下一个事件（如果有）前3小时。新活动应在同一天计划

在这种情况下，它将在id=2之后和上午11点插入新事件

我开始做了一些事情，但最后却出现了一打“如果”，几个小时后我开始思考：

    // for each event, check if there's time before or after (not less than 5am, not more than 11:59pm)
    for(var i = 0; i < events.length; i++) {
        var eventTime = events[i].start.clone();
        var before = eventTime.clone();
        var after = eventTime.clone();
        before.subtract('hours', 3);
        after.add('hours', 3);
        if(i == 0 && !before.hour() < 5 && !before.isBefore(date, 'day')) {
            // first event of the day, new time cannot be before 5am and cannot be on the previous day
            hour = before.hour();
        } else if(i == 0 && !after.isAfter(date, 'day')) {
            // same as above but we test time + 3h
        } else if(i == events.length - 1 && !after.isAfter(date, 'day')) {
            // last event of the day, new time cannot be the next day (after 11:59pm)
            hour = after.hour();
        } else if (i > 0 && i < events.length - 1) {
            // middle events
            // new time should be at least 3H after previous event and 3H before next event
            // ex: 5h, 8h, 12h ok but 5h, 8h, 10h not ok or 5h, 6h, 9h not ok
            var previousEventTime = events[i-1].start.clone();
            var nextEventTime = events[i+1].start.clone();
            if(before.hour() >= previousEventTime.hour() && after.hour() <= nextEventTime.hour()) {

            }
            //
        }
    }

//对于每个事件，检查之前或之后是否有时间（不少于上午5点，不超过晚上11:59）
对于（var i=0；i0&&i如果（before.hour（）>=previousEventTime.hour（）&&after.hour（）在花了一天时间之后，我想出了一个“数学”解决方案

在我的数组中，我想在事件x和事件z之间插入一个事件y（x是前一个事件，z是下一个事件）

由于每次活动之间至少需要3个小时，我想：

x+3 <= y-3 || y+3 <= z-3

由于我的大脑离烧坏不远，代码看起来是这样的

        for(var i = 0; i < events.length; i++) {
            var x = null;
            var y = events[i].start.clone().hour();
            var z = null;
            if(i > 0) {
                x = events[i-1].start.clone().hour();
            }
            if(i < events.length -1) {
                z = events[i+1].start.clone().hour();
            }
            // first event or only event
            if(i == 0) {
                // check if removing 3h00 doesn't cross the 5am limit
                if(y - 3 >= 5) {
                    hour = y - 3;
                } else if(z-y >= 6) {
                    // check if there's enough time before next event
                    hour = y + 3;
                }
            }
            // middle event
            if(x && z) {
                if (y-x >= 6) {
                    hour = y - 3;
                } else if (z-y >= 6) {
                    hour = y + 3;
                }
            }
            // last event (can also be first if only 1 element)
            // with !hour we make sure that a "middle" event hour is not overriden if found above
            if(!hour && i == events.length - 1 && i != 0) {
                // check if adding 3h00 doesn't change day (23h00)
                if(y + 3 <= 23) {
                    hour = y + 3;
                } else if(y-x >= 6) {
                    // check if there's enough time after previous event
                    hour = y - 3;
                }
            }
        }
        return hour;

for（变量i=0；i0）{
x=事件[i-1]。开始。克隆（）.hour（）；
}
如果（i=5）{
小时=y-3；
}否则如果（z-y>=6）{
//检查下一次活动之前是否有足够的时间
小时=y+3；
}
}
//中间事件
if（x&&z）{
如果（y-x>=6）{
小时=y-3；
}否则如果（z-y>=6）{
小时=y+3；
}
}
//最后一个事件（如果只有1个元素，也可以是第一个）
//对于！hour，我们确保在上面找到的情况下不会覆盖“中间”事件小时
如果（！hour&&i==events.length-1&&i！=0）{
//检查添加3h00是否不改变日期（23h00）
如果（y+3=6）{
//检查前一事件后是否有足够的时间
小时=y-3；
}
}
}
返程时间；

我很乐意接受一个改进此算法的答案。
输出应该是什么？它可以是一个整数，表示一天中可以插入事件的时间。（本例中为11）
y-x > =6 || z-y >= 6

        for(var i = 0; i < events.length; i++) {
            var x = null;
            var y = events[i].start.clone().hour();
            var z = null;
            if(i > 0) {
                x = events[i-1].start.clone().hour();
            }
            if(i < events.length -1) {
                z = events[i+1].start.clone().hour();
            }
            // first event or only event
            if(i == 0) {
                // check if removing 3h00 doesn't cross the 5am limit
                if(y - 3 >= 5) {
                    hour = y - 3;
                } else if(z-y >= 6) {
                    // check if there's enough time before next event
                    hour = y + 3;
                }
            }
            // middle event
            if(x && z) {
                if (y-x >= 6) {
                    hour = y - 3;
                } else if (z-y >= 6) {
                    hour = y + 3;
                }
            }
            // last event (can also be first if only 1 element)
            // with !hour we make sure that a "middle" event hour is not overriden if found above
            if(!hour && i == events.length - 1 && i != 0) {
                // check if adding 3h00 doesn't change day (23h00)
                if(y + 3 <= 23) {
                    hour = y + 3;
                } else if(y-x >= 6) {
                    // check if there's enough time after previous event
                    hour = y - 3;
                }
            }
        }
        return hour;