时间范围减法：从主时间段中移除子时间段

本教程旨在解决从一组主时间段中移除特定子时间段的问题。我们将探讨一种实用的javascript算法，通过遍历和条件判断，将重叠的主时间段精确地分割为不包含子时间段的新区间，从而实现时间范围的有效管理和数据清洗。

引言：时间段的移除与分割

在数据处理和业务逻辑中，我们经常需要对时间范围进行操作，例如从一个较大的时间段中排除某个特定的子时间段。这种需求在日程管理、资源预订、数据分析等领域尤为常见。本教程将提供一个具体的解决方案，演示如何通过编程实现这一目标，尤其是在子时间段完全包含在主时间段内部的场景。

核心问题分析

假设我们有两组时间范围数据，每组都包含多个具有开始时间和结束时间的对象：

• xyz：一组主时间段，代表原始的、完整的可用时间。
• abc：一组需要从 xyz 中移除的子时间段，代表需要排除的占用时间。

我们的目标是生成一个新的 xyz 数组，其中所有 abc 中定义的冲突时间段都被精确地移除。例如，如果 xyz 中有一个时间段是 [09:00, 18:00]，而 abc 中有一个时间段是 [16:30, 17:30]，那么最终 xyz 应该变为 [09:00, 16:30] 和 [17:30, 18:00]。

原始数据示例：

var abc = [
   {
      "start": "2021-11-25 16:30:00",
      "end": "2021-11-25 17:30:00"
   }
];

var xyz = [
   {
      "start": "2021-11-25 09:00:00",
      "end": "2021-11-25 18:00:00"
   },
   {
      "start": "2021-11-26 15:00:00",
      "end": "2021-11-26 19:00:00"
   }
];

期望输出示例：

xyz = [
   {
      "start": "2021-11-25 09:00:00",
      "end": "2021-11-25 16:30:00"
   },
   {
      "start": "2021-11-25 17:30:00",
      "end": "2021-11-25 18:00:00"
   },
   {
      "start": "2021-11-26 15:00:00",
      "end": "2021-11-26 19:00:00"
   }
];

解决方案设计

解决此问题的核心思路是遍历 xyz 中的每一个时间段，然后针对每一个 xyz 时间段，检查它是否与 abc 中的任何时间段存在冲突。如果存在冲突，并且 abc 时间段完全包含在 xyz 时间段内部，我们就将 xyz 时间段分割成两个新的时间段，从而排除 abc 部分。如果不存在冲突，则 xyz 时间段保持不变。

美间AI

美间AI：让设计更简单

45

查看详情

具体步骤如下：

1. 初始化结果数组：创建一个空数组 newXyz 来存储处理后的时间段。
2. 遍历主时间段：对 xyz 数组中的每个时间段进行迭代。
3. 时间戳转换：为了方便比较，将所有时间字符串转换为统一的时间戳（例如毫秒数）。
4. 冲突检测：对于当前的 xyz 时间段，遍历 abc 数组中的所有时间段。
   • 判断 abc 时间段的开始时间是否在 xyz 时间段的开始时间和结束时间之间。这是检测 abc 包含在 xyz 内部的关键条件。
5. 时间段分割：如果检测到冲突（即 abc 包含在 xyz 内）：
   • 将 xyz 时间段从其开始到 abc 的开始时间分割为第一个新时间段。
   • 如果 abc 的结束时间也在 xyz 的结束时间之前，则将 xyz 时间段从 abc 的结束时间到 xyz 的结束时间分割为第二个新时间段。
   • 标记已检测到冲突，并停止对当前 xyz 时间段的 abc 遍历（因为我们只处理第一个冲突）。
6. 无冲突处理：如果遍历完所有 abc 时间段后，当前 xyz 时间段未检测到冲突，则将其原样添加到 newXyz 数组中。
7. 更新主数组：最后，将 newXyz 赋值给 xyz。

JavaScript 实现示例

以下是根据上述设计实现的 JavaScript 代码：

var abc = [
   {
      "start": "2021-11-25 16:30:00",
      "end": "2021-11-25 17:30:00"
   }
];

var xyz = [
   {
      "start": "2021-11-25 09:00:00",
      "end": "2021-11-25 18:00:00"
   },
   {
      "start": "2021-11-26 15:00:00",
      "end": "2021-11-26 19:00:00"
   }
];

var newXyz = []; // 用于存储处理后的新时间段
for (var i in xyz) {
  // 将当前 xyz 时间段的开始和结束时间转换为时间戳
  var start = new Date(xyz[i]["start"]).getTime();
  var end = new Date(xyz[i]["end"]).getTime();
  var collisionDetected = false; // 标记是否检测到冲突

  for (var j in abc) {
    // 将当前 abc 时间段的开始和结束时间转换为时间戳
    var start2 = new Date(abc[j]["start"]).getTime();
    var end2 = new Date(abc[j]["end"]).getTime();

    // 冲突检测条件：
    // 如果 abc 的开始时间在 xyz 的开始和结束时间之间
    // 这意味着 abc 至少部分地包含在 xyz 内部
    if (start2 > start && start2 < end) {
      // 添加 xyz 的第一部分：从 xyz 的开始到 abc 的开始
      newXyz.push({"start": xyz[i]["start"], "end": abc[j]["start"]});

      // 如果 abc 的结束时间也在 xyz 的结束时间之前
      // 这意味着 abc 完全包含在 xyz 内部，并且后面还有剩余部分
      if (end2 < end) {
        // 添加 xyz 的第二部分：从 abc 的结束到 xyz 的结束
        newXyz.push({"start": abc[j]["end"], "end": xyz[i]["end"]});
      }
      collisionDetected = true; // 标记冲突已处理
      break; // 针对当前 xyz 时间段，只处理第一个发现的 abc 冲突并跳出内层循环
    }
  }

  // 如果当前 xyz 时间段没有与任何 abc 时间段发生冲突
  if (collisionDetected == false) {
    // 将原始的 xyz 时间段添加到结果中
    newXyz.push({"start": xyz[i]["start"], "end": xyz[i]["end"]});
  }
}

xyz = newXyz; // 更新 xyz 数组为处理后的结果

console.dir(xyz);

代码解析：

1. 时间戳转换：new Date(dateString).getTime() 是将日期字符串转换为自1970年1月1日00:00:00 UTC以来的毫秒数。这种数字形式便于进行大小比较。
2. 外层循环：for (var i in xyz) 遍历 xyz 数组中的每一个主时间段。
3. 内层循环：for (var j in abc) 遍历 abc 数组中的每一个要移除的子时间段，与当前 xyz 时间段进行比较。
4. 冲突条件：if (start2 > start && start2 < end) 是此算法的核心。它判断 abc 时间段的开始时间 start2 是否严格地位于 xyz 时间段的 start 和 end 之间。这精确地捕捉了 abc 时间段的起始点在 xyz 内部的情况。
5. 分割逻辑：
   • 如果满足冲突条件，首先将 xyz 时间段的前半部分 [xyz.start, abc.start] 加入 newXyz。
   • 接着，if (end2 < end) 检查 abc 的结束时间是否在 xyz 的结束时间之前。如果成立，说明 xyz 在 abc 之后还有剩余部分，于是将 [abc.end, xyz.end] 作为后半部分加入 newXyz。
6. break 语句：在检测到并处理了第一个冲突后，break 语句会立即跳出内层循环。这意味着对于一个 xyz 时间段，如果它与多个 abc 时间段重叠，此代码只会处理第一个发现的 abc 冲突。
7. 无冲突处理：if (collisionDetected == false) 确保那些未与任何 abc 时间段冲突的 xyz 时间段被完整地保留下来。

注意事项与扩展

1. 特定冲突场景：当前解决方案主要针对 abc 时间段完全包含在 xyz 时间段内部，并且 abc 的起始点在 xyz 内部的场景。它能够正确处理示例中的情况。
2. 更复杂的重叠情况：
   • 部分重叠：例如 abc 从 xyz 的左侧开始重叠 (abc.start < xyz.start < abc.end)，或者从右侧重叠 (abc.start < xyz.end < abc.end)。
   • 完全包含：abc 完全包含 xyz (abc.start <= xyz.start && abc.end >= xyz.end)。
   • 多重冲突：一个 xyz 时间段与多个 abc 时间段重叠。 当前代码中的 break 语句意味着它只处理一个 xyz 时间段的第一次 abc 冲突。对于需要处理所有重叠并进行复杂区间合并或减法的场景，需要更通用的区间算法（例如，先将所有区间排序，然后进行合并或减法操作）。
3. 日期库的使用：在实际项目中，推荐使用成熟的日期处理库，如 Moment.js (legacy) 或 date-fns (modern)，它们提供了更健壮和易用的日期解析、格式化和比较功能，可以避免原生 Date 对象在不同浏览器和时区下可能出现的细微差异。
4. 性能考量：对于大规模时间段数据，嵌套循环的性能开销会随着数据量增加而显著上升。如果性能成为瓶颈，可以考虑对时间段进行预排序，然后采用更高效的算法（例如扫描线算法）来处理重叠和合并问题。

总结

本教程提供了一个在 JavaScript 中从一组主时间段中移除特定子时间段的实用方法。通过将日期字符串转换为时间戳，并利用嵌套循环和条件判断，我们能够有效地识别并分割重叠的时间段，从而生成符合需求的新时间段集合。虽然此方案专注于处理子时间段完全包含在主时间段内部的特定场景，但其核心逻辑为理解更复杂的时间范围操作奠定了基础。在实际应用中，根据具体业务需求和数据规模，可能需要进一步扩展或优化算法以应对更多样化的时间段重叠模式。

以上就是时间范围减法：从主时间段中移除子时间段的详细内容，更多请关注php中文网其它相关文章！