基于下面的案例，使用javascript在房间调度系统中搜索可用房间的最佳逻辑是什么

我很难制定逻辑来完成我的日程安排系统

案例：

我有以下房间的时间表： 07:00-15:00

根据上面的房间时间表，我已经有了如下的预订清单：

08:00-10:00

10:00-11:00

12:00-15:00

我想要的结果是：

07:00-08:00->可用

08:00-10:00->预订

10:00-11:00->预订

11:00-12:00->可用

12:00-15:00->预订

以前有人有过这样的病例吗？ 任何想法或建议都将不胜感激。

---

谢谢。

我想这在很大程度上取决于您的预订数据当前的结构，但我的第一个想法是组合一个时间段数组并相应地标记它们

例如，如果您的最短预订时间为1小时，那么一天有8节课：

[0,0,0,0,0,0,0,0]

应用当前预订将导致：

[0,1,1,1,0,1,1,1]

---

当您生成可用性列表时，您将连接连续的值。

这将为您提供从roomAvailable开始到结束的可用插槽。 我在可能的地方添加了评论

var-roomAvailable={
开始：“07:00”，
完:"十五时"
}
//获取时间的数值
var getValue=函数（时间）{
var arr=时间分割（“：”）；
var val=arr[0]*60+arr[1]*1；
返回val；
}
//转换为可读的时间字符串
var toTimeString=函数（val）{
var hr=数学楼层（val/60）；
var最小值=val%60；
如果（hr<10）hr=“0”+hr；
如果（最小值<10）min=“0”+min；
返回hr+“：”+min；
}
var=[{
开始：“08:00”，
完:"十时三十分"
},
{
开始：“10:40”，
完:"十一时"
},
{
开始：“12:00”，
完:"十五时"
}
];
var printSlot=函数（a，b）{
log（toTimeString（a）+“-”+toTimeString（b））；
}
var getAvailableSlots=功能（房间可用、预订）{
//按开始时间对预订的时段进行排序[可选]
var bookedsorded=booked.sort（函数（a，b）{
var x=getValue（a.start）；
变量y=获取值（b.开始）；
if（xy）{
返回1；
}
返回0；
});
var bookingStart=getValue（roomAvailable.start）；
var bookingEnd=getValue（roomAvailable.end）；
//现在从bookingStart开始
var oStart=bookingStart；
var i=0；
while（oStartgetAvailableSlots（房间可用，已预订）我带着我的结果回来，实现@lecstor的想法

完整源代码：

exports.exprocedure = function(req,res){
var minT = 7;
var maxT = 15;
var arraySession = [];

//Booked Time
//08:00 - 10:00
//10:00 - 11:00
//12:00 - 15:00
var arrayBookingPerTrans    = [{start:8,finish:10},{start:10,finish:11},{start:12,finish:15}];
var arrayBookPerHour        = [];
var avSession               = [];

//split session
for(var i = minT; i < maxT; i++)
{
    arraySession.push({
        start:i,
        finish:i+1
    });
}
console.log("Session :");
console.log(arraySession);

//split booked time
for(var a=0;a<arrayBookingPerTrans.length;a++)
{
    for(var j = arrayBookingPerTrans[a].start; j < arrayBookingPerTrans[a].finish; j++)
    {
        arrayBookPerHour.push({
            start:j,
            finish:j+1,
            Trans:a
        })
    }
}
console.log("Booking Per Hour :");
console.log(arrayBookPerHour);

//filter to find available time
var avSession  = arraySession.filter(function(array_el){
    return arrayBookPerHour.filter(function(anotherOne_el)
    {
        return anotherOne_el.start == array_el.start;
    }).length == 0
});

console.log("Available :");
console.log(avSession);

//push available time and booked time in an array
var allArray = [];
var sum = avSession.length + arrayBookingPerTrans.length;
for(var i=0;i<avSession.length;i++)
{
    allArray.push({
        start  : avSession[i].start,
        finish : avSession[i].finish,
        state  : 'Available'
    });
}

for(var i=0;i<arrayBookingPerTrans.length;i++)
{
    allArray.push({
        start  : arrayBookingPerTrans[i].start,
        finish : arrayBookingPerTrans[i].finish,
        state  : 'Booked'
    });
}

//sorting 
function compare(a, b) {
    const startA = a.start
    const startB = b.start

    let comparison = 0;
    if (startA > startB) {
      comparison = 1;
    } else if (startA < startB) {
      comparison = -1;
    }
    return comparison;
}

  console.log("RESULT SORTING");
  console.log(allArray.sort(compare));

res.json({ 
    result      :'success',
    content     : allArray 
});}

优秀@Sunil，你的比我的好，短，非常感谢：）
Available Time :
[ { start: 7, finish: 8 }, { start: 11, finish: 12 } ]

RESULT SORTING : 
[{start: 7, finish: 8, state: 'Available' },
{ start: 8, finish: 10, state: 'Booked' },
{ start: 10, finish: 11, state: 'Booked' },
{ start: 11, finish: 12, state: 'Available' },
{ start: 12, finish: 15, state: 'Booked' } ]