日报为什么多算一天：先固定时区和统计窗口

所以本窗口应得到 start、inside、same，总数为 3 个唯一事件；切换至 9 月 28 日 21:00 至 29 日 21:00 的下一窗口，同一份输入应得到 end、after，总数为 2。后一组只是在重算这七行数据，不表示下一整天只有两个事件。

二、明确只支持哪些时间写法

这不是通用日期解析器。输入限定为已解析的普通 JSON 值，事件数组每条取 id 和 at，其他字段忽略。ID 为 1 至 16 个 ASCII 字符，首位是小写英文字母，其余只能用小写字母、数字或连字符；按原字符串比较，不去空格、不转大小写。

at、窗口 start 和 end 都必须完整符合 YYYY-MM-DDTHH:mm:ss.sssZ 或 YYYY-MM-DDTHH:mm:ss.sss+08:00。年份限定 2000 至 2099；日期须真实存在；小时为 00 至 23，分与秒为 00 至 59；毫秒固定三位。大写 T、Z、冒号和偏移不可省略。不支持其他偏移、闰秒、24 点、自然语言日期、日期后附时区名称或外围空白。

完整年月日时分秒毫秒后缺少时区，明确报 TIMEZONE_REQUIRED；不合格式报 TIME_FORMAT；不是字符串报 TIME_TYPE；不合法日期报 INVALID_DATE。限制年份同时避开 Date.UTC 对 0 至 99 年的特殊处理。本例先按自己的窄语法取出数字，再用 UTC 数值构造与逐项等价回读确认日期，不调用 Date.parse(text) 或 new Date(text)。ECMAScript 对缺偏移的日期时间文本采用本地时间解释，非标准文本还存在实现差异，不能把这种隐式解释当成数据约定。ECMAScript：Date.parse

窗口的 zone 也必须显式提供，只支持本例自定义的固定显示标签 UTC 和 UTC+08:00。它只决定 startDisplay、endDisplay 怎样给人看，不改变两个端点代表的时间点，也不改变成员集合。因此这里故意拒绝 Asia/Shanghai 等 IANA 名称；北京时间的这组演示使用固定 UTC+08:00，不处理历史时区规则或夏令时。

同一 ID、同一时间点表示同一事件，保留首行计数；不同 ID 即使同时发生，仍是不同事件。若同一 ID 对应两个不同时间点，报 EVENT_TIME_CONFLICT，整批不返回计数，即使其中一个时间点落在窗口外也一样。不能靠输入顺序决定信哪条。

三、保存完整脚本并运行

把以下全部代码存为 time-window.cjs，运行 node time-window.cjs。无需安装第三方包；脚本不联网、不读业务数据、不写数据库，每组虚构输入输出一行 JSON。本文实际运行环境为 macOS、Node.js v22.22.0。

代码把用于比较的毫秒值与显示字符串分开。Date.UTC 使用 UTC 解释数字参数；它可以把越界日期滚动到另一日期，因此还要回读比对，不能以“得到了数值”判定日期合法。ECMAScript：Date.UTC

'use strict';
class InputError extends Error {
  constructor(code, path) { super(code); this.code = code; this.path = path; }
}
const fail = (code, path) => { throw new InputError(code, path); };
const HOUR = 3600000;
const fullMatch = (re, text) => {
  const m = re.exec(text);
  return m && m[0] === text ? m : null;
};
function parseInstant(text, path) {
  if (typeof text !== 'string') fail('TIME_TYPE', path);
  if (fullMatch(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}$/, text)) {
    fail('TIMEZONE_REQUIRED', path);
  }
  const m = fullMatch(/^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})\.(\d{3})(Z|\+08:00)$/, text);
  if (!m) fail('TIME_FORMAT', path);
  const [y, mo, d, h, mi, s, ms] = m.slice(1, 8).map(Number);
  if (y < 2000 || y > 2099) fail('YEAR_RANGE', path);
  const wallAsUtc = Date.UTC(y, mo - 1, d, h, mi, s, ms);
  // Date.UTC can normalize an impossible date; require exact component round-trip.
  if (new Date(wallAsUtc).toISOString() !== text.slice(0, 23) + 'Z') {
    fail('INVALID_DATE', path);
  }
  return wallAsUtc - (m[8] === '+08:00' ? 8 * HOUR : 0);
}
function display(instant, zone) {
  if (zone === 'UTC') return new Date(instant).toISOString();
  return new Date(instant + 8 * HOUR).toISOString().slice(0, -1) + '+08:00';
}
function countEvents(events, config) {
  try {
    if (!config || typeof config !== 'object' || Array.isArray(config)) {
      fail('WINDOW_OBJECT', 'window');
    }
    const { start, end, zone } = config;
    if (zone === undefined || zone === null || zone === '') fail('TIMEZONE_REQUIRED', 'window.zone');
    if (zone !== 'UTC' && zone !== 'UTC+08:00') fail('WINDOW_ZONE', 'window.zone');
    const startMs = parseInstant(start, 'window.start');
    const endMs = parseInstant(end, 'window.end');
    if (startMs >= endMs) fail('WINDOW_ORDER', 'window');
    if (!Array.isArray(events)) fail('EVENTS_ARRAY', 'events');
    const seen = new Map();
    const includedIds = [];
    const decisions = [];
    for (let i = 0; i < events.length; i++) {
      const row = events[i];
      const path = `events[${i}]`;
      if (!row || typeof row !== 'object' || Array.isArray(row)) fail('EVENT_OBJECT', path);
      if (typeof row.id !== 'string' || !fullMatch(/^[a-z][a-z0-9-]{0,15}$/, row.id)) {
        fail('EVENT_ID', path + '.id');
      }
      const instant = parseInstant(row.at, path + '.at');
      const duplicate = seen.has(row.id);
      if (duplicate && seen.get(row.id) !== instant) fail('EVENT_TIME_CONFLICT', path + '.at');
      seen.set(row.id, instant);
      const inWindow = startMs <= instant && instant < endMs;
      const counted = inWindow && !duplicate;
      const reason = duplicate ? 'SAME_EVENT_DUPLICATE'
        : instant < startMs ? 'BEFORE_START'
        : instant === startMs ? 'AT_START'
        : instant < endMs ? 'INSIDE'
        : instant === endMs ? 'AT_END' : 'AFTER_END';
      if (counted) includedIds.push(row.id);
      decisions.push({ row: i + 1, id: row.id, instantUtc: new Date(instant).toISOString(), inWindow, counted, reason });
    }
    return {
      ok: true,
      window: { zone, startUtc: new Date(startMs).toISOString(), endUtc: new Date(endMs).toISOString(), startDisplay: display(startMs, zone), endDisplay: display(endMs, zone) },
      count: includedIds.length, includedIds, decisions
    };
  } catch (error) {
    if (!(error instanceof InputError)) throw error;
    return { ok: false, error: { code: error.code, path: error.path } };
  }
}
const window = { start: '2026-09-27T21:00:00.000+08:00', end: '2026-09-28T21:00:00.000+08:00', zone: 'UTC+08:00' };
const events = [
  { id: 'before', at: '2026-09-27T20:59:59.999+08:00' },
  { id: 'start', at: '2026-09-27T21:00:00.000+08:00' },
  { id: 'inside', at: '2026-09-28T00:00:00.000+08:00' },
  { id: 'same', at: '2026-09-28T04:00:00.000Z' },
  { id: 'same', at: '2026-09-28T12:00:00.000+08:00' },
  { id: 'end', at: '2026-09-28T21:00:00.000+08:00' },
  { id: 'after', at: '2026-09-28T21:00:00.001+08:00' }
];
const samples = {
  boundaries: { events, window },
  utc_display: { events, window: { ...window, zone: 'UTC' } },
  next_window: { events, window: { ...window, start: window.end, end: '2026-09-29T21:00:00.000+08:00' } },
  empty: { events: [], window }
};
const invalidTimes = [
  ['missing_event_zone', '2026-09-28T12:00:00.000'],
  ['invalid_day', '2026-02-30T12:00:00.000Z'],
  ['invalid_month', '2026-13-01T12:00:00.000Z'],
  ['unsupported_offset', '2026-09-28T12:00:00.000+09:00'],
  ['missing_millis', '2026-09-28T12:00:00Z'],
  ['hour_24', '2026-09-28T24:00:00.000Z'],
  ['leap_second', '2026-09-28T12:00:60.000Z'],
  ['trailing_newline', '2026-09-28T12:00:00.000Z\n'],
  ['year_0099', '0099-09-28T12:00:00.000Z'],
  ['year_2100', '2100-09-28T12:00:00.000Z'],
  ['time_not_string', null]
];
for (const [name, at] of invalidTimes) samples[name] = { events: [{ id: 'x', at }], window };
const conflict = [{ id: 'same', at: '2026-09-28T04:00:00.000Z' }, { id: 'same', at: '2026-09-28T13:00:00.000Z' }];
samples.conflict = { events: conflict, window };
samples.conflict_reversed = { events: [...conflict].reverse(), window };
samples.missing_window_zone = { events: [], window: { start: window.start, end: window.end } };
samples.unsupported_window_zone = { events: [], window: { ...window, zone: 'Asia/Shanghai' } };
samples.equal_window = { events: [], window: { ...window, end: window.start } };
samples.reverse_window = { events: [], window: { ...window, start: window.end, end: window.start } };
samples.missing_start_zone = { events: [], window: { ...window, start: '2026-09-27T21:00:00.000' } };
samples.not_array = { events: {}, window };
samples.bad_record = { events: [null], window };
samples.empty_id = { events: [{ id: '', at: window.start }], window };
if (require.main === module) {
  for (const [name, input] of Object.entries(samples)) {
    console.log(JSON.stringify({ name, result: countEvents(input.events, input.window) }));
  }
}
module.exports = { countEvents, samples };

四、对照具体结果和错误位置

boundaries 的摘要应为以下内容；实际每行报告还带 decisions，逐条保留行号、ID、UTC 时间、inWindow、counted 和 reason。row 从 1 起，错误 path 中数组下标从 0 起。

{
  "ok": true,
  "window": {
    "zone": "UTC+08:00",
    "startUtc": "2026-09-27T13:00:00.000Z",
    "endUtc": "2026-09-28T13:00:00.000Z",
    "startDisplay": "2026-09-27T21:00:00.000+08:00",
    "endDisplay": "2026-09-28T21:00:00.000+08:00"
  },
  "count": 3,
  "includedIds": [
    "start",
    "inside",
    "same"
  ]
}

七条决策原因按输入顺序应为 BEFORE_START、AT_START、INSIDE、INSIDE、SAME_EVENT_DUPLICATE、AT_END、AFTER_END。第 5 行的 inWindow 为 true，counted 为 false：在窗口内与增加唯一事件数是两个判断。有效结果中的 instantUtc 使用带 Z 的 UTC 格式供核对，成员判断已经在格式化之前完成。ECMAScript：toISOString

utc_display 的总数与 ID 集合仍为 3 和 start、inside、same，只是窗口展示改为 UTC；next_window 的第 6 行从 AT_END 变为 AT_START，开始纳入下一份报告；empty 则合法返回 0 和空数组。不要把错误也显示成 0，这会混淆“没有事件”和“这次无法计算”。

其余示例都有明确失败预期：

• missing_event_zone 与 missing_start_zone 分别在 events[0].at 和 window.start 报 TIMEZONE_REQUIRED；missing_window_zone 在 window.zone 报同一错误码。
• invalid_day、invalid_month、hour_24、leap_second 在 events[0].at 报 INVALID_DATE；不会自动变成下个月或下一天。
• unsupported_offset、missing_millis、trailing_newline 报 TIME_FORMAT，不偷偷修正文本。year_0099 与 year_2100 报 YEAR_RANGE；time_not_string 报 TIME_TYPE，位置均为 events[0].at。
• conflict 与 conflict_reversed 都在第二条的 events[1].at 报 EVENT_TIME_CONFLICT，两种顺序都没有部分计数。
• unsupported_window_zone 在 window.zone 报 WINDOW_ZONE；equal_window、reverse_window 在 window 报 WINDOW_ORDER。
• not_array 在 events 报 EVENTS_ARRAY；bad_record 在 events[0] 报 EVENT_OBJECT；empty_id 在 events[0].id 报 EVENT_ID。

函数采用遇到首个错误即停止，不是一次报告所有错误：先检查窗口对象、显示时区、开始、结束及顺序，再检查事件数组，最后按行检查对象、ID、时间与冲突。窗口本身不是对象时还会报 WINDOW_OBJECT。错误报告只含 ok: false 与 error，不会混入一个看起来可用的 count。代码不会把意外程序异常伪装成输入错误。

五、这次实际验证到哪里

2026 年 9 月 28 日北京时间 09:04:10，先冻结了虚构输入、窄语法规则和 25 组完整预期报告；当时尚未实现函数。09:05:13 在 Node.js v22.22.0 本地执行，25 组实际报告逐项匹配预期，25 组输入在调用前后不变，深度冻结输入后再次调用也符合预期。以上是本次本地运行记录，不是线上业务结果。

另外分别在 TZ=Etc/UTC 和 TZ=America/Los_Angeles 的独立 Node 进程运行同一完整脚本，各自 25 行报告都符合冻结期望，两个输出文件的字节哈希一致。Node 的 TZ 会影响进程时区配置，这两次运行用于检查本例有没有意外依赖机器默认时区；不等于已经测试洛杉矶的夏令时窗口规则。Node.js：TZ

本次执行源码 SHA-256 为 ee50feaa9665084b3ad498aeff6495393a0f39225add291013d5b1bff75ff735；独立输入文件 SHA-256 为 490215b9329b97c308c30ed9783a7460c8175c74c6768ffd762ebb6609d5bf35。哈希用于固定已验证的版本，本身不替代上述结果比较。

这套证据只支持固定输入下的时间解析、窗口成员判断和 ID 去重。没有覆盖所有合法日期、跨月跨年组合、所有偏移、IANA 时区、夏令时变化、迟到事件补账、删除记录、并发快照、数据库查询或真实日报采集；也没有把事件数量转换为金额或人数。固定 UTC+08:00 示例中的 24 小时，不能推广为所有地区的每个自然日都恰好 24 小时。

接到真实报表任务时，可以先写一张很短的约定：统计哪种事件，以发生时间还是入库时间为准，窗口的两个端点是什么，ID 如何定义，错误是否停止，以及迟到数据如何处理。再把开始前、恰好开始、窗口内、恰好结束、结束后和同一事件的两种表示逐条列出来。若你的结果仍多一条，欢迎带着脱敏后的两端时间、事件 ID 和预期归属讨论；不要只给一个总数，也不要贴真实账号或订单资料。