如何高效计算起止日期间复杂时间单元的迭代次数？

我正在使用Moment.js库，支持用{years:1,months:1,weeks:1,days:1,hours:1,minutes:1,seconds:1}这类格式定义复杂时间单元。但由于不同月份天数不同（比如1月31日加1个月会变成2月28日）、闰年等因素，简单的数学计算无法得出起止日期间该时间单元的迭代次数。

我目前用的是暴力循环法：不断把时间单元加到起始日期，直到超过结束日期后统计次数，但如果时间单元是分钟且计算跨年度时，这个方法速度极慢。

测试代码 #

let start = "2021-01-01 00:00";
let end = "2023-01-01 00:00";
let unit = {years: 1, months: 1, weeks: 1, days: 1, hours: 1, minutes: 1};

let startMoment = moment(start, 'YYYY-MM-DD HH:mm');
let endMoment = moment(end, 'YYYY-MM-DD HH:mm');

let startEndDurationSeconds = endMoment.diff(startMoment, "seconds");
let startEndDurationMinutes = endMoment.diff(startMoment, "minutes");
let startEndDurationHours = endMoment.diff(startMoment, "hours");
let startEndDurationDays = endMoment.diff(startMoment, "days");
let startEndDurationWeeks = endMoment.diff(startMoment, "weeks");
let startEndDurationMonths = endMoment.diff(startMoment, "months");
let startEndDurationYears = endMoment.diff(startMoment, "years");

console.log(`seconds=${startEndDurationSeconds}`);
console.log(`minutes=${startEndDurationMinutes}`);
console.log(`hours=${startEndDurationHours}`);
console.log(`days=${startEndDurationDays}`);
console.log(`weeks=${startEndDurationWeeks}`);
console.log(`months=${startEndDurationMonths}`);
console.log(`years=${startEndDurationYears}`);

现有暴力循环代码 #

function countIterations(start, end, duration) {
    let remainingStart = moment(start);
    let remainingEnd = moment(end);
    let i = 0;
    while (remainingStart <= remainingEnd) {
        i++;
        remainingStart.add(duration);
    }
    return i - 1;
 }
let duration = {years: 0, months: 1, weeks: 1, days: 0, hours: 0, minutes: 0};
let iterations = countIterations(moment(start), moment(end), duration);
console.log(iterations);

这个方法虽然可行但效率极低，请问有没有无需暴力循环的高效方法，能计算起止日期间复杂时间单元的迭代次数？

核心思路是用二分查找替代暴力循环，把时间复杂度从O(n)降到O(log n)。因为Moment.js的add方法遵循日历逻辑的时间增量规则，我们可以通过二分法快速找到最大的k值，使得起始日期 + k*时间单元 <= 结束日期。

实现代码 #

function countIterationsOptimized(start, end, duration) {
    const startMoment = moment(start);
    const endMoment = moment(end);
    
    // 边界情况：起始时间已超过结束时间
    if (startMoment.isAfter(endMoment)) return 0;
    
    let low = 0;
    // 初始化足够大的上限值，用秒级差值除以单步最小可能秒数（按1分钟估算）
    const maxSeconds = endMoment.diff(startMoment, 'seconds');
    let high = Math.ceil(maxSeconds / 60) + 1;
    
    let best = 0;
    while (low <= high) {
        const mid = Math.floor((low + high) / 2);
        const testDate = moment(startMoment).add(mid, duration);
        
        if (testDate.isSameOrBefore(endMoment)) {
            // 当前mid可行，尝试更大的数值
            best = mid;
            low = mid + 1;
        } else {
            // 当前mid超出范围，尝试更小的数值
            high = mid - 1;
        }
    }
    return best;
}

// 测试示例
let start = "2021-01-01 00:00";
let end = "2023-01-01 00:00";
let duration = {years: 0, months: 1, weeks: 1, days: 0, hours: 0, minutes: 0};
console.log(countIterationsOptimized(start, end, duration));

高效原因 #

• 二分查找的次数仅与迭代次数的对数相关，哪怕需要百万次迭代，也只需要约20次计算
• 每次计算仅调用一次moment().add()和日期比较，开销远小于循环累加
• 完全遵循Moment.js的日历时间逻辑，不会出现月份天数、闰年等计算误差

额外优化点 #

1. 根据时间单元的最大单位优化上限值，比如包含年份时，用年份差值的2倍作为初始上限，进一步减少查找次数
2. 重复计算场景下，缓存起始日期的副本，避免重复初始化Moment实例

内容的提问来源于stack exchange，提问作者Joseph Astrahan