乐趣区

关于javascript:JS判定一个给定的时间区间在哪些时间段范围内

jiezi

有这样的一个场景：给定一个工夫区间，须要断定这个工夫区间在哪些时间段范畴内.

比方时间段范畴如下：

[["00:00","01:00"],["01:00","02:00"],["02:00","03:00"],["03:00","04:00"],["04:00","05:00"],["05:00","06:00"],["06:00","07:00"],["07:00","08:00"],["08:00","09:00"],["09:00","10:00"],["10:00","11:00"],["11:00","12:00"],["12:00","13:00"],["13:00","14:00"],["14:00","15:00"],["15:00","16:00"],["16:00","17:00"],["17:00","18:00"],["18:00","19:00"],["19:00","20:00"],["20:00","21:00"],["21:00","22:00"],["22:00","23:00"],["23:00","24:00"]]

当初给定一个工夫区间 10:15-16:38，那么就须要返回 [“10:00″,”11:00”],[“11:00″,”12:00”],[“12:00″,”13:00”],[“13:00″,”14:00”],[“14:00″,”15:00”],[“15:00″,”16:00”],[“16:00″,”17:00”] 这些时间段范畴。

1、惯例工夫区间断定

假如给定的工夫区间为 [st, et]，时间段范畴为 [t1, t2]，那么 [st, et] 在 [t1, t2] 范畴内的断定根据有以下几种状况：

  • t1 >= st && t2 <= et；
  • st >= t1 && st <= t2；
  • et >= t1 && et <= t2；

再来看看 给定工夫区间不在时间段范畴内，即 [st, et] 不在 [t1, t2] 范畴内的断定根据：

  • st < t1 && et < t1；
  • st > t2 && et > t2；

从下面的断定根据来看，给定工夫区间不在时间段范畴内的断定根据更简略，对其取反，即可失去正确的时间段范畴，上面给出具体的断定代码：

function judge(startTime, endTime) {
    // 生成 24 小时工夫区间，跨度为 1 小时
    let timeArrays = new Array(24).fill(['','']).map((item, index) => [(index < 10 ? '0' + index : index) + ':00', ((index + 1) < 10 ? '0' + (index + 1) : (index + 1)) + ':00']);

    return timeArrays.filter(item => !((compare(item[0], startTime) && compare(item[0], endTime)) || (compare(startTime, item[1]) && compare(endTime, item[1]))));
}

function compare(startTime, endTime) {
    // 将工夫转换为分钟，再进行比拟
    let startTimes = startTime.split(':');
    let endTimes = endTime.split(':');
    let startTimeVal = startTimes[0] * 60 + Number(startTimes[1]);
    let endTimeVal = endTimes[0] * 60 + Number(endTimes[1]);

    return startTimeVal >= endTimeVal;
}

上面来验证一下 10:15-16:38 这个工夫区间

console.log(JSON.stringify(judge('10:15', '16:38')))

输入的后果如下：

[["10:00","11:00"],["11:00","12:00"],["12:00","13:00"],["13:00","14:00"],["14:00","15:00"],["15:00","16:00"],["16:00","17:00"]]

2、蕴含临界点工夫区间的断定

如果给定的工夫区间蕴含了临界工夫点，比方 10:00-17:00，那么后果又是如何呢？

console.log(JSON.stringify(judge('10:00', '17:00')))

此时输入的后果如下：

[["10:00","11:00"],["11:00","12:00"],["12:00","13:00"],["13:00","14:00"],["14:00","15:00"],["15:00","16:00"],["16:00","17:00"]]

在理论的利用中，对于临界点工夫可能有不同的规定，具体有以下三种场景：

（1）同时算两个工夫区间内，比方 16:00，既算做位于 [“15:00″,”16:00”]，也算做位于 [“16:00″,”17:00”] 区间；

（2）临界工夫作为完结工夫，比方 16:00，那么就只算做位于 [“15:00″,”16:00”] 区间；

（3）临界工夫作为起始工夫，比方 16:00，那么就只算做位于 [“16:00″,”17:00”] 区间；

如果想同时满足下面的三个场景，那么就须要对断定办法进行革新，通过传入相应的参数进行管制，革新后的代码如下：

function judge(startTime, endTime, leftEquals, rightEquals) {
    // 生成 24 小时工夫区间，跨度为 1 小时
    let timeArrays = new Array(24).fill(['','']).map((item, index) => [(index < 10 ? '0' + index : index) + ':00', ((index + 1) < 10 ? '0' + (index + 1) : (index + 1)) + ':00']);

    return timeArrays.filter(item => !((compare(item[0], startTime, leftEquals) && compare(item[0], endTime, rightEquals)) || (compare(startTime, item[1], leftEquals) && compare(endTime, item[1], rightEquals))));
}

function compare(startTime, endTime, equals) {
    // 将工夫转换为分钟，再进行比拟
    let startTimes = startTime.split(':');
    let endTimes = endTime.split(':');
    let startTimeVal = startTimes[0] * 60 + Number(startTimes[1]);
    let endTimeVal = endTimes[0] * 60 + Number(endTimes[1]);

    return equals ? startTimeVal >= endTimeVal : startTimeVal > endTimeVal;
}

上面别离测试一下上述的三个场景：

场景一：两边都蕴含，因为是取反的断定形式，所以两个参数都须要传 false

console.log(JSON.stringify(judge('10:00', '12:00', false, false)))

输入后果如下：

[["09:00","10:00"],["10:00","11:00"],["11:00","12:00"],["12:00","13:00"]]

场景二：临界点作为完结工夫

console.log(JSON.stringify(judge('10:00', '12:00', false, true)))

输入后果如下：

[["09:00","10:00"],["10:00","11:00"],["11:00","12:00"]]

场景三：临界点作为起始工夫

console.log(JSON.stringify(judge('10:00', '12:00', true, false)))

输入后果如下：

[["10:00","11:00"],["11:00","12:00"],["12:00","13:00"]]

3、工夫区间逾越 0 点的断定

在下面探讨的两种状况中，都没有思考到给定的工夫区间逾越 0 点的问题，即完结工夫小于起始工夫的状况，比方 10:15-01:23，那么对于这种状况，又须要怎么解决呢？

如果工夫区间逾越了 0 点，那么就相当于存在两个工夫区间，即 10:15-24:00 和 00:00-01:23，此时就是对两个工夫区间进行断定，革新后的代码如下：

function judge(startTime, endTime, leftEquals, rightEquals) {
    // 宰割工夫区间，断定完结工夫是否小于起始工夫
    let targetTimes = compare(startTime, endTime, false) ? [[startTime, '24:00'], ['00:00', endTime]] : [[startTime, endTime]];
    // 生成 24 小时工夫区间，跨度为 1 小时
    let timeArrays = new Array(24).fill(['','']).map((item, index) => [(index < 10 ? '0' + index : index) + ':00', ((index + 1) < 10 ? '0' + (index + 1) : (index + 1)) + ':00']);

    return timeArrays.filter(item => targetTimes.some(target => !((compare(item[0], target[0], leftEquals) && compare(item[0], target[1], rightEquals))
        || (compare(target[0], item[1], leftEquals) && compare(target[1], item[1], rightEquals)))));
}

function compare(startTime, endTime, equals) {
    // 将工夫转换为分钟，再进行比拟
    let startTimes = startTime.split(':');
    let endTimes = endTime.split(':');
    let startTimeVal = startTimes[0] * 60 + Number(startTimes[1]);
    let endTimeVal = endTimes[0] * 60 + Number(endTimes[1]);

    return equals ? startTimeVal >= endTimeVal : startTimeVal > endTimeVal;
}

上面验证一下 10:15-01:23 这个工夫区间

console.log(JSON.stringify(judge('10:15', '01:23', false, true)))

输入后果如下

[["00:00","01:00"],["01:00","02:00"],["10:00","11:00"],["11:00","12:00"],["12:00","13:00"],["13:00","14:00"],["14:00","15:00"],["15:00","16:00"],["16:00","17:00"],["17:00","18:00"],["18:00","19:00"],["19:00","20:00"],["20:00","21:00"],["21:00","22:00"],["22:00","23:00"],["23:00","24:00"]]
退出移动版