Swift中如何精确计算两个日期间的小数年份间隔？

我需要精确计算两个日期之间的年份间隔。由于不同年份的天数存在差异（部分闰年为366天），无法直接通过两日期间的天数除以365来得到精确结果。请问有没有比以下实现更直接或更精确的方法？

用户原实现代码 #

import Foundation

func isLeapYear(_ year: Int) -> Bool {
    return (year % 4 == 0 && year % 100 != 0) || year % 400 == 0
}

func countLeapYears(_ startDate: Date, _ endDate: Date) -> (leapYears: Int, nonLeapYears: Int) {
    let calendar = Calendar.current
    
    let startYear = calendar.component(.year, from: startDate)
    let endYear = calendar.component(.year, from: endDate)
    
    var leapYears = 0
    var nonLeapYears = 0
    
    for year in startYear...endYear {
        if isLeapYear(year) {
            leapYears += 1
        } else {
            nonLeapYears += 1
        }
    }
    
    return (leapYears, nonLeapYears)
}

func yearsBetween(_ startDate: Date, _ endDate: Date) -> Double {
    let calendar = Calendar.current
    
    let totalSeconds = endDate.timeIntervalSince(startDate)
    
    let secondsInCommonYear = 365.0 * 24 * 60 * 60
    let secondsInLeapYear = 366.0 * 24 * 60 * 60
    
    let (leap, nonleap) = countLeapYears(startDate, endDate)
    let nominator = (Double(nonleap) * secondsInCommonYear + Double(leap) * secondsInLeapYear)
    let denominator = (nonleap + leap)
    let averageSecondsInYear = nominator / Double(denominator)
    
    let years = totalSeconds / averageSecondsInYear
    
    return years
}

let startDate = Calendar.current.date(byAdding: .year, value: -46, to: .now)!
let endDate = Date.now
yearsBetween(startDate, endDate) // returns 46.00069901

更直接且精确的实现方式 #

你的当前实现通过计算平均年长度转换秒数，但存在一定误差。以下两种方法能更精准地计算年份间隔，同时简化代码逻辑：

方法一：利用Calendar组件计算（推荐） #

系统Calendar类已经封装了日期差值的精确计算逻辑，能自动处理闰年、月份天数差异等场景。我们可以先获取完整年份差，再计算剩余日期占当前年份的比例：

import Foundation

func preciseYearsBetween(startDate: Date, endDate: Date) -> Double {
    let calendar = Calendar.current
    
    // 获取两个日期之间的完整年份
    guard let fullYears = calendar.dateComponents([.year], from: startDate, to: endDate).year else {
        return 0
    }
    
    // 计算当前年份的起始日期
    let currentYearStart = calendar.date(from: calendar.dateComponents([.year], from: endDate))!
    // 当前年份的总秒数（自动处理闰年）
    let currentYearTotalSeconds = calendar.date(byAdding: .year, value: 1, to: currentYearStart)!.timeIntervalSince(currentYearStart)
    // 剩余日期的秒数
    let remainingSeconds = endDate.timeIntervalSince(currentYearStart)
    
    // 完整年份 + 剩余日期占当前年份的比例
    return Double(fullYears) + (remainingSeconds / currentYearTotalSeconds)
}

// 测试示例
let testStart = Calendar.current.date(byAdding: .year, value: -46, to: .now)!
let testEnd = Date.now
print(preciseYearsBetween(startDate: testStart, endDate: testEnd))

方法二：逐年份累加实际时间间隔 #

如果需要极致精度，可以遍历每个完整年份，累加实际时间间隔，最后加上剩余部分的比例：

import Foundation

func exactYearsBetween(startDate: Date, endDate: Date) -> Double {
    let calendar = Calendar.current
    var currentDate = startDate
    var fullYearsCount = 0
    
    // 遍历所有完整年份
    while let nextYearDate = calendar.date(byAdding: .year, value: 1, to: currentDate), nextYearDate <= endDate {
        fullYearsCount += 1
        currentDate = nextYearDate
    }
    
    // 计算剩余日期占当前年份的比例
    let remainingSeconds = endDate.timeIntervalSince(currentDate)
    let currentYearTotalSeconds = calendar.date(byAdding: .year, value: 1, to: currentDate)!.timeIntervalSince(currentDate)
    
    return Double(fullYearsCount) + (remainingSeconds / currentYearTotalSeconds)
}

// 测试示例
let testStart = Calendar.current.date(byAdding: .year, value: -46, to: .now)!
let testEnd = Date.now
print(exactYearsBetween(startDate: testStart, endDate: testEnd))

方案优势 #

• 精度更高：基于实际日期的时间间隔计算，完全避免平均年长度带来的误差
• 代码更简洁：复用系统CalendarAPI，无需自行实现闰年判断、年份遍历等逻辑，减少出错概率
• 自动兼容边缘场景：跨世纪闰年、时区转换、不同月份天数差异等情况，系统API已自动处理

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