Javascript 如何查找没有日期部分的时间间隔之间的重叠

我必须找出两个时间范围之间的重叠，它不包括比较中的日期部分，但只包括时间，例如范围_1为上午9点至下午6点，范围_2为下午5点至上午8点。实际时间为24小时格式。我已经编写了一个解决方案，可以找到重叠，但在任何时间都是跨天/午夜之后（例如晚上10点到凌晨2点）时，它都不起作用

这两个时间都在同一天，但我当前的解决方案在午夜后的任何时间都无法正确进行比较。例如，它在范围_1:9AM-6PM和范围_2:5PM-8PM的情况下给出正确的输出，在范围_1:10PM-2AM和范围_2:1AM-3AM的情况下给出正确的5PM-6PM重叠输出，但无法找到重叠。 以下是指向我的代码笔的链接：

范围1:10PM-2AM

范围2:凌晨1点至凌晨3点

正确的输出应为：1 AM至2 AM

---

由于两个时间重叠，所有时间都在一天之内，不包括任何日期。考虑到2个学生每天在这些时间学习，如果这两个时间重叠的话，

我只需要工作几小时/分钟就可以：

const较小=（a，b）=>a.hoursa.hours==b.hours&&a.mins==b.mins；
功能重叠（a、b）{
如果（更小（a.to，a.from））{
返回[
…重叠（{from:{hours:0，mins:0}，to:a.to}，b），
…重叠（{from:a.from，to:{hours:24，mins:0}}，b），
];
}
if（更小（b.to，b.from））{
返回[
…重叠（a，{from:{hours:0，mins:0}，to:a.to}），
…重叠（a，{from:a.from，to:{hours:24，mins:0}），
];
}
常数结果={
from：更小（b.from，a.from）？a.from:b.from，
to：更小的（a.to，b.to）？a.to:b.to，
};
返回等于（result.from，result.to）？[]：[result]；
}
控制台日志（[
[
{从：{小时：6，分钟：10}到：{小时：8，分钟：10}，
{从：{小时：6分钟：10}到：{小时：8分钟：10}
],  [
{从：{小时：7，分钟：10}到：{小时：10，分钟：10}，
{从：{小时：6分钟：10}到：{小时：8分钟：10}
],  [
{从：{小时：23，分钟：10}到：{小时：8，分钟：10}，
{从：{小时：6分钟：10}到：{小时：8分钟：10}
]
].map（[a，b]）=>`${JSON.stringify（a）}\n与${JSON.stringify（b）}\n在${JSON.stringify（重叠（a，b））}\n\n`）中重叠；

我只需要工作几小时/分钟，然后：

const较小=（a，b）=>a.hoursa.hours==b.hours&&a.mins==b.mins；
功能重叠（a、b）{
如果（更小（a.to，a.from））{
返回[
…重叠（{from:{hours:0，mins:0}，to:a.to}，b），
…重叠（{from:a.from，to:{hours:24，mins:0}}，b），
];
}
if（更小（b.to，b.from））{
返回[
…重叠（a，{from:{hours:0，mins:0}，to:a.to}），
…重叠（a，{from:a.from，to:{hours:24，mins:0}），
];
}
常数结果={
from：更小（b.from，a.from）？a.from:b.from，
to：更小的（a.to，b.to）？a.to:b.to，
};
返回等于（result.from，result.to）？[]：[result]；
}
控制台日志（[
[
{从：{小时：6，分钟：10}到：{小时：8，分钟：10}，
{从：{小时：6分钟：10}到：{小时：8分钟：10}
],  [
{从：{小时：7，分钟：10}到：{小时：10，分钟：10}，
{从：{小时：6分钟：10}到：{小时：8分钟：10}
],  [
{从：{小时：23，分钟：10}到：{小时：8，分钟：10}，
{从：{小时：6分钟：10}到：{小时：8分钟：10}
]
].map（[a，b]）=>`${JSON.stringify（a）}\n与${JSON.stringify（b）}\n在${JSON.stringify（重叠（a，b））}\n\n`）中重叠；

有许多棘手的问题需要解决，比如do “10:00，11:00”和“11:00，12:00”重叠？“10:00，10:00”是零分钟还是24小时

在任何情况下，我要做的就是把时间转换成午夜后的几分钟，然后进行比较。这段代码的作用是。比较是“一个持续时间的开始时间”与“另一个持续时间的开始/结束时间”，如果不是，则交换时间并再次进行检查

function overlap(t0, t1) {
    // convert time to minutes past midnight
    var minutes = (d) => {return Object.values(d).map(d => {
        d=d.split(':').map(d=>parseInt(d));
        return d[0]*60+d[1];
    })};
    // If the end time is before the start then add 24 hours to the end
    // time to wrap it into next day. start==end gets 24 hrs added.
    var nextday = (d) => {if(d[0]>=d[1])d[1]+=24*60;return d}
    t0 = nextday(minutes(t0));
    t1 = nextday(minutes(t1));
    var olap = (t0, t1) => {
        // beginning of t0 between begin/end of t1
        // or
        // end of t0 between begin/end of t1
        return (t0[0]>=t1[0] && t0[0]<=t1[1]) 
            || (t1[0]>=t0[0] && t1[0]<=t0[1]);
    }
    return olap(t0, t1) || olap(t1, t0)
}

功能重叠（t0、t1）{
//将时间转换为午夜后的分钟数
var minutes=（d）=>{return Object.values（d）.map（d=>{
d=d.split（'：'）.map（d=>parseInt（d））；
返回d[0]*60+d[1]；
})};
//如果结束时间早于开始时间，则在结束时间加上24小时
//是时候把它包装到第二天了。开始==结束加上24小时。
var nextday=（d）=>{if（d[0]>=d[1]）d[1]+=24*60；返回d}
t0=下一天（分钟（t0））；
t1=下一天（分钟（t1））；
var olap=（t0，t1）=>{
//t1开始/结束之间的t0开始
//或
//t1开始/结束之间的t0结束
return（t0[0]>=t1[0]&&t0[0]=t0[0]&&t1[0]有许多角落的案例需要整理，就像do一样
“10:00，11:00”和“11:00，12:00”重叠？10:00，10:00是零分钟还是24小时

在任何情况下，我这样做的方式是将时间转换为午夜后的分钟数并进行比较。这段代码所做的就是这样。比较是“一个持续时间的开始时间”与“另一个持续时间的开始/结束时间”，如果不是，则交换时间并再次进行检查

function overlap(t0, t1) {
    // convert time to minutes past midnight
    var minutes = (d) => {return Object.values(d).map(d => {
        d=d.split(':').map(d=>parseInt(d));
        return d[0]*60+d[1];
    })};
    // If the end time is before the start then add 24 hours to the end
    // time to wrap it into next day. start==end gets 24 hrs added.
    var nextday = (d) => {if(d[0]>=d[1])d[1]+=24*60;return d}
    t0 = nextday(minutes(t0));
    t1 = nextday(minutes(t1));
    var olap = (t0, t1) => {
        // beginning of t0 between begin/end of t1
        // or
        // end of t0 between begin/end of t1
        return (t0[0]>=t1[0] && t0[0]<=t1[1]) 
            || (t1[0]>=t0[0] && t1[0]<=t0[1]);
    }
    return olap(t0, t1) || olap(t1, t0)
}

功能重叠（t0、t1）{
//将时间转换为午夜后的分钟数
var minutes=（d）=>{return Object.values（d）.map（d=>{
d=d.split（'：'）.map（d=>parseInt（d））；
返回d[0]*60+d[1]；
})};
//如果结束时间早于开始时间，则在结束时间加上24小时
//是时候把它包装到第二天了。开始==结束加上24小时。
var nextday=（d）=>{if（d[0]>=d[1]）d[1]+=24*60；返回d}
t0=下一天（分钟（t0））；
t1=下一天（分钟（t1））；
var olap=（t0，t1）=>{
//t1开始/结束之间的t0开始