Javascript 在数据数组中查找下一个可用时隙

我有一个包含“事件”数组的数组，其中包含一个事件数组

$data = array(
'events'=> array(
    array(
    'title' => 't1',
    'start_time' => '12:00AM',
    'end_time' => '1:00AM',
    ),
        array(
    'title' => 't1',
    'start_time' => '1:00PM',
    'end_time' => '1:30PM',
    ),
        array(
    'title' => 't1',
    'start_time' => '1:30PM',
    'end_time' => '2:00PM',
    ),
        array(
    'title' => 't1',
    'start_time' => '3:15PM',
    'end_time' => '3:45PM',
    ),
        array(
    'title' => 't1',
    'start_time' => '3:45PM',
    'end_time' => '4:45PM',
    )
    )
);

根据当前时间，我正在努力找到下一个至少15分钟的可用时间段。假设现在是下午1:15，下一个可用的时间段是下午2:00（根据提供的数据数组）。这似乎很容易，但我被难倒了

下面的代码就是我所在的位置。如果在当前时间发生事件，它将返回标题，但我不确定如何获得下一个未被占用的时间段

$time = time();
$timePlus15 = time() + 60*15;

foreach ($events->events as $key => $event) {
    $start_time = strtotime($event->start_time);
    $end_time = strtotime($event->end_time);

        if (($time > $start_time && $timePlus15 < $end_time) || $time > $start_time && $time < $end_time || ($time < $start_time && $timePlus15 > $start_time && $timePlus15 < $end_time)) {
            echo $event->title;
    }
}

$time=time（）；
$timePlus15=时间（）+60*15；
foreach（$events->events as$key=>$event）{
$start\u time=strottime（$event->start\u time）；
$end\u time=strottime（$event->end\u time）；
如果（$time>$start_time&&$timePlus15<$end_time）|$time>$start_time&$time<$end_time |（$time<$start_time&$timePlus15>$start_time&$timePlus15<$end_time））{
echo$event->title；
}
}

基本上，我想在数组中循环。如果当前发生事件，则将时间增加15分钟，然后再次检查。如果有事件，则增加15分钟并再次检查，然后重复，直到此时没有事件，然后返回该时间

代码是用php编写的，但我也会接受javascript/jquery的答案

**我的问题的解决办法如下**

this.setNextAvailableTime = function() {
    var requiredGap = 15 * 60 * 1000;
    var events = app.rooms.events[app.rooms.current_room].events;
    var prev = events[0];
    var firstGap = null;
    if (events.length === 1) {
        firstGap = prev.end_24time;
    } else {
        for (var i = 1; i < events.length; i += 1) {

            var current = events[i];

            var current_start = new Date();
            var prev_end = new Date();
            current_start.setHours(events[i].start_24time.substring(0,2),events[i].start_24time.substring(3,5), 0);
            prev_end.setHours(prev.end_24time.substring(0,2),prev.end_24time.substring(3,5), 0);

            var diff = current_start.getTime() - prev_end.getTime();

            if( diff >= requiredGap) {
                firstGap = prev.end_24time;
                break;
            }

            prev = current;
        }           
    }
    //do something with the firstGap time
    $('#start_time').val(firstGap);
};

this.setNextAvailableTime=function（）{
所需var间隙=15*60*1000；
var events=app.rooms.events[app.rooms.current_room].events；
var prev=事件[0]；
var firstGap=null；
如果（events.length==1）{
firstGap=prev.end_24时间；
}否则{
对于（变量i=1；i=所需间隙）{
firstGap=prev.end_24时间；
打破
}
prev=当前值；
}           
}
//在第一次休息时间做点什么
$（'start#u time'）.val（firstGap）；
};
可能更容易看出第一个事件的
结束
与下一个事件的
开始
之间的区别。下面是一个javascript示例：

（注意字符串到日期的转换不是很可靠，只是一些测试数据）


var事件=[{
开始：“2016-01-01T12:00”，
完：“2016-01-01T13:00”
}, {
开始：“2016-01-01T13:00”，
完：“2016-01-01T13:30”
}, {
开始：“2016-01-01T13:30”，
完：“2016-01-01T14:00”
}, {
开始：“2016-01-01T15:15”，
完：“2016-01-01T15:45”
}, {
开始：“2016-01-01T15:45”，
完：“2016-01-01T16:45”
}];
var dateEvents=events.map（函数（事件）{
返回{
开始：新日期（事件开始），
结束：新日期（event.end）
};
});
所需var间隙=15*60*1000；
var prev=dateEvents[0]；
var firstGap=null；
对于（变量i=1；i=所需间隙）{
第一间隙={
开始：上一个，
结束：current.start
};
打破
}
prev=当前值；
}
if（firstGap！=null）{
log（“第一个间隙开始于：”+firstGap.start）；
}否则{
console.log（“无可用间隙”）；
}
可能更容易看出第一个事件的
结束
与下一个事件的
开始
之间的区别。下面是一个javascript示例：

（注意字符串到日期的转换不是很可靠，只是一些测试数据）


var事件=[{
开始：“2016-01-01T12:00”，
完：“2016-01-01T13:00”
}, {
开始：“2016-01-01T13:00”，
完：“2016-01-01T13:30”
}, {
开始：“2016-01-01T13:30”，
完：“2016-01-01T14:00”
}, {
开始：“2016-01-01T15:15”，
完：“2016-01-01T15:45”
}, {
开始：“2016-01-01T15:45”，
完：“2016-01-01T16:45”
}];
var dateEvents=events.map（函数（事件）{
返回{
开始：新日期（事件开始），
结束：新日期（event.end）
};
});
所需var间隙=15*60*1000；
var prev=dateEvents[0]；
var firstGap=null；
对于（变量i=1；i=所需间隙）{
第一间隙={
开始：上一个，
结束：current.start
};
打破
}
prev=当前值；
}
if（firstGap！=null）{
log（“第一个间隙开始于：”+firstGap.start）；
}否则{
console.log（“无可用间隙”）；
}
Javascript解决方案。在es6fiddle中运行：

将字符串转换为分钟，反之亦然，这是大部分实际工作。之后，它只需创建一个数组，该数组表示事件之间的可用时间，而不是事件所花费的时间。为此，我使用了一个稍微作弊的
map
（作弊是因为我转发了一个元素，这不是一个真正的函数方法，但嘿，它是JS）。接下来，找到第一个开始时间等于或晚于当前时间且至少有15分钟可用时间的位置

从概念上讲很简单，只是字符串到时间的转换很麻烦。它可以从午夜工作到午夜，而不是跨天工作。我用你的辛勤工作时间字符串，而不是其他解决方案，这不是你张贴，所以考虑一个“接受”，因为它与你的实际输入工作）p>
let eventsArr=[{title:'t1'，start_time:'1:00PM'，end_time:'1:30PM'}，
{标题：'t1'，开始时间：'1:30PM'，结束时间：'2:00PM'}，
{标题：“t1”，开始时间：
let eventsArr = [{title: 't1', start_time: '1:00PM', end_time: '1:30PM'},
                 {title: 't1', start_time: '1:30PM', end_time: '2:00PM'},
                 {title: 't1', start_time: '3:15PM', end_time: '3:45PM'}]

function strTimeToMins(c) {
    let rex = /([0-9]|0[0-9]|1[0-9]|2[0-3]):([0-5][0-9])([P,p,A,a])/
    let mat = c.match(rex)
    return 60*mat[1] + 1*mat[2] + ((mat[3] === 'P') ? 720 : 0)
}

function minsToStrTime(m) {
    let hr = Math.floor(m/60)
    let min = m%60
    let hours = (hr > 12 ? hr-12 : hr)
    return hours.toString() + ':' + ("00" + min).slice(-2) + (hr > 12 ? 'PM' : 'AM')
}

function objTimeToMins(o) {
    return { title: o.title,
             start_time: strTimeToMins(o.start_time),
             end_time: strTimeToMins(o.end_time) }
    }

let eventsArrMins = eventsArr.map(objTimeToMins)

let openTimes = eventsArrMins.map( (c,i,a) => ( (i+1 != a.length) ?
    { start: c.end_time, end: a[i+1].start_time } : {} ))

//let currTime = strTimeToMins ('1:15PM')
let currTime = Math.floor((new Date() - new Date().setHours(0,0,0,0))/1000)

let nextAvailable = openTimes.find(c => currTime <= c.start && c.end - c.start >= 15)

if (nextAvailable)
    console.log('Next available time is: ' + minsToStrTime(nextAvailable.start))
else
    console.log('There are no available times.')