日期计算与比较
2025年3月7日大约 17 分钟
日期计算与比较
日期计算包括日期比较、日期差值计算、日期加减等操作。本文将介绍如何使用JavaScript的Date对象进行各种日期计算和比较操作。
日期比较
在JavaScript中，可以直接使用比较运算符来比较Date对象，因为Date对象可以自动转换为时间戳进行比较。
基本比较
const date1 = new Date(2023, 0, 1); // 2023年1月1日
const date2 = new Date(2023, 5, 15); // 2023年6月15日
const date3 = new Date(2023, 0, 1); // 与date1相同的日期
// 比较两个日期
console.log(date1 < date2); // true（date1早于date2）
console.log(date1 > date2); // false（date1不晚于date2）
console.log(date1 <= date3); // true
console.log(date1 >= date3); // true
// 检查日期是否相等
console.log(date1 === date3); // false（引用不同）
console.log(date1 == date3); // false（引用不同）
// 正确比较日期是否相等（比较时间戳）
console.log(date1.getTime() === date3.getTime()); // true日期相等性检查
// 检查两个日期是否表示相同的时间点
function areDatesEqual(date1, date2) {
return date1.getTime() === date2.getTime();
}
// 检查两个日期是否表示同一天（忽略时间部分）
function areSameDay(date1, date2) {
return date1.getFullYear() === date2.getFullYear() &&
date1.getMonth() === date2.getMonth() &&
date1.getDate() === date2.getDate();
}
const morning = new Date(2023, 0, 1, 9, 0); // 2023年1月1日 9:00
const evening = new Date(2023, 0, 1, 21, 0); // 2023年1月1日 21:00
console.log(areDatesEqual(morning, evening)); // false（时间不同）
console.log(areSameDay(morning, evening)); // true（同一天）日期范围检查
// 检查日期是否在指定范围内
function isDateInRange(date, startDate, endDate) {
return date >= startDate && date <= endDate;
}
const targetDate = new Date(2023, 2, 15); // 2023年3月15日
const rangeStart = new Date(2023, 0, 1); // 2023年1月1日
const rangeEnd = new Date(2023, 11, 31); // 2023年12月31日
console.log(isDateInRange(targetDate, rangeStart, rangeEnd)); // true日期差值计算
计算两个日期之间的毫秒数
const start = new Date(2023, 0, 1); // 2023年1月1日
const end = new Date(2023, 0, 2); // 2023年1月2日
// 计算毫秒差
const diffMs = end.getTime() - start.getTime();
console.log(diffMs); // 86400000（一天的毫秒数）计算天数差
// 计算两个日期之间的天数差
function getDaysDiff(date1, date2) {
// 将日期设置为当天的开始时间（00:00:00）以确保准确计算天数
const d1 = new Date(date1);
d1.setHours(0, 0, 0, 0);
const d2 = new Date(date2);
d2.setHours(0, 0, 0, 0);
// 计算毫秒差并转换为天数
const diffMs = Math.abs(d2 - d1);
return Math.floor(diffMs / (1000 * 60 * 60 * 24));
}
const date1 = new Date(2023, 0, 1); // 2023年1月1日
const date2 = new Date(2023, 0, 10); // 2023年1月10日
console.log(getDaysDiff(date1, date2)); // 9计算工作日差
// 计算两个日期之间的工作日数量（不包括周六和周日）
function getWorkingDaysDiff(startDate, endDate) {
// 确保startDate早于endDate
let start = new Date(Math.min(startDate, endDate));
let end = new Date(Math.max(startDate, endDate));
// 设置为当天的开始时间
start.setHours(0, 0, 0, 0);
end.setHours(0, 0, 0, 0);
// 计算总天数
const totalDays = Math.floor((end - start) / (1000 * 60 * 60 * 24));
// 计算周末天数
let weekendDays = 0;
for (let i = 0; i <= totalDays; i++) {
const day = new Date(start);
day.setDate(start.getDate() + i);
// 0表示周日，6表示周六
const dayOfWeek = day.getDay();
if (dayOfWeek === 0 || dayOfWeek === 6) {
weekendDays++;
}
}
// 工作日 = 总天数 - 周末天数
return totalDays - weekendDays + 1; // +1是因为包括起始日
}
const start = new Date(2023, 0, 2); // 2023年1月2日（周一）
const end = new Date(2023, 0, 8); // 2023年1月8日（周日）
console.log(getWorkingDaysDiff(start, end)); // 5（周一到周五）计算年、月、日差值
// 计算两个日期之间的年、月、日差值
function getDateDifference(startDate, endDate) {
// 确保startDate早于endDate
let start = new Date(Math.min(startDate, endDate));
let end = new Date(Math.max(startDate, endDate));
let years = end.getFullYear() - start.getFullYear();
let months = end.getMonth() - start.getMonth();
let days = end.getDate() - start.getDate();
// 调整月份和年份
if (days < 0) {
months--;
// 获取上个月的天数
const lastMonth = new Date(end.getFullYear(), end.getMonth(), 0);
days += lastMonth.getDate();
}
if (months < 0) {
years--;
months += 12;
}
return { years, months, days };
}
const birthDate = new Date(1990, 5, 15); // 1990年6月15日
const today = new Date(2023, 5, 20); // 2023年6月20日
const age = getDateDifference(birthDate, today);
console.log(`${age.years}年${age.months}个月${age.days}天`); // "33年0个月5天"日期加减操作
添加/减去天数
// 添加天数
function addDays(date, days) {
const result = new Date(date);
result.setDate(result.getDate() + days);
return result;
}
// 减去天数
function subtractDays(date, days) {
return addDays(date, -days);
}
const today = new Date(2023, 5, 15); // 2023年6月15日
// 添加7天
const nextWeek = addDays(today, 7);
console.log(nextWeek); // 2023年6月22日
// 减去3天
const threeDaysAgo = subtractDays(today, 3);
console.log(threeDaysAgo); // 2023年6月12日添加/减去月份
// 添加月份
function addMonths(date, months) {
const result = new Date(date);
result.setMonth(result.getMonth() + months);
return result;
}
// 减去月份
function subtractMonths(date, months) {
return addMonths(date, -months);
}
const today = new Date(2023, 5, 15); // 2023年6月15日
// 添加3个月
const threeMonthsLater = addMonths(today, 3);
console.log(threeMonthsLater); // 2023年9月15日
// 减去1个月
const lastMonth = subtractMonths(today, 1);
console.log(lastMonth); // 2023年5月15日
// 处理月末日期
const jan31 = new Date(2023, 0, 31); // 2023年1月31日
const feb31 = addMonths(jan31, 1);
console.log(feb31); // 2023年2月28日（2月没有31日，自动调整）添加/减去年份
// 添加年份
function addYears(date, years) {
const result = new Date(date);
result.setFullYear(result.getFullYear() + years);
return result;
}
// 减去年份
function subtractYears(date, years) {
return addYears(date, -years);
}
const today = new Date(2023, 5, 15); // 2023年6月15日
// 添加5年
const fiveYearsLater = addYears(today, 5);
console.log(fiveYearsLater); // 2028年6月15日
// 减去10年
const tenYearsAgo = subtractYears(today, 10);
console.log(tenYearsAgo); // 2013年6月15日
// 处理闰年
const feb29_2020 = new Date(2020, 1, 29); // 2020年2月29日（闰年）
const feb29_2021 = addYears(feb29_2020, 1);
console.log(feb29_2021); // 2021年2月28日（非闰年自动调整）添加/减去小时、分钟和秒
// 添加小时
function addHours(date, hours) {
const result = new Date(date);
result.setHours(result.getHours() + hours);
return result;
}
// 添加分钟
function addMinutes(date, minutes) {
const result = new Date(date);
result.setMinutes(result.getMinutes() + minutes);
return result;
}
// 添加秒
function addSeconds(date, seconds) {
const result = new Date(date);
result.setSeconds(result.getSeconds() + seconds);
return result;
}
const now = new Date(2023, 5, 15, 14, 30, 0); // 2023年6月15日 14:30:00
// 添加2小时
console.log(addHours(now, 2)); // 2023年6月15日 16:30:00
// 添加45分钟
console.log(addMinutes(now, 45)); // 2023年6月15日 15:15:00
// 添加30秒
console.log(addSeconds(now, 30)); // 2023年6月15日 14:30:30
// 跨天计算
console.log(addHours(now, 12)); // 2023年6月16日 02:30:00日期舍入操作
舍入到天的开始或结束
// 获取某一天的开始时间（00:00:00.000）
function startOfDay(date) {
const result = new Date(date);
result.setHours(0, 0, 0, 0);
return result;
}
// 获取某一天的结束时间（23:59:59.999）
function endOfDay(date) {
const result = new Date(date);
result.setHours(23, 59, 59, 999);
return result;
}
const now = new Date(2023, 5, 15, 14, 30, 45); // 2023年6月15日 14:30:45
console.log(startOfDay(now)); // 2023年6月15日 00:00:00.000
console.log(endOfDay(now)); // 2023年6月15日 23:59:59.999舍入到月的开始或结束
// 获取某月的第一天
function startOfMonth(date) {
const result = new Date(date);
result.setDate(1);
result.setHours(0, 0, 0, 0);
return result;
}
// 获取某月的最后一天
function endOfMonth(date) {
const result = new Date(date);
// 设置为下个月的第0天，即本月的最后一天
result.setMonth(result.getMonth() + 1, 0);
result.setHours(23, 59, 59, 999);
return result;
}
const now = new Date(2023, 5, 15); // 2023年6月15日
console.log(startOfMonth(now)); // 2023年6月1日 00:00:00.000
console.log(endOfMonth(now)); // 2023年6月30日 23:59:59.999舍入到年的开始或结束
// 获取某年的第一天
function startOfYear(date) {
const result = new Date(date);
result.setMonth(0, 1);
result.setHours(0, 0, 0, 0);
return result;
}
// 获取某年的最后一天
function endOfYear(date) {
const result = new Date(date);
result.setMonth(11, 31);
result.setHours(23, 59, 59, 999);
return result;
}
const now = new Date(2023, 5, 15); // 2023年6月15日
console.log(startOfYear(now)); // 2023年1月1日 00:00:00.000
console.log(endOfYear(now)); // 2023年12月31日 23:59:59.999舍入到周的开始或结束
// 获取某周的第一天（周日或周一，取决于地区）
function startOfWeek(date, startOnMonday = true) {
const result = new Date(date);
const day = result.getDay();
// 计算需要减去的天数
// 如果startOnMonday为true，则周一为一周的开始（0->6, 1->0, 2->1, ...）
// 如果startOnMonday为false，则周日为一周的开始（0->0, 1->1, 2->2, ...）
const diff = startOnMonday ? (day === 0 ? 6 : day - 1) : day;
result.setDate(result.getDate() - diff);
result.setHours(0, 0, 0, 0);
return result;
}
// 获取某周的最后一天
function endOfWeek(date, startOnMonday = true) {
const firstDay = startOfWeek(date, startOnMonday);
const result = new Date(firstDay);
result.setDate(result.getDate() + 6);
result.setHours(23, 59, 59, 999);
return result;
}
const now = new Date(2023, 5, 15); // 2023年6月15日（假设是周四）
// 以周一为一周的开始
console.log(startOfWeek(now)); // 2023年6月12日（周一）00:00:00.000
console.log(endOfWeek(now)); // 2023年6月18日（周日）23:59:59.999
// 以周日为一周的开始
console.log(startOfWeek(now, false)); // 2023年6月11日（周日）00:00:00.000
console.log(endOfWeek(now, false)); // 2023年6月17日（周六）23:59:59.999日期迭代
遍历日期范围
// 遍历两个日期之间的每一天
function* eachDayOfInterval(startDate, endDate) {
let currentDate = new Date(startDate);
// 设置为当天的开始时间
currentDate.setHours(0, 0, 0, 0);
const end = new Date(endDate);
end.setHours(0, 0, 0, 0);
while (currentDate <= end) {
yield new Date(currentDate);
currentDate.setDate(currentDate.getDate() + 1);
}
}
// 使用示例
const start = new Date(2023, 5, 1); // 2023年6月1日
const end = new Date(2023, 5, 5); // 2023年6月5日
for (const day of eachDayOfInterval(start, end)) {
console.log(day.toISOString().split('T')[0]); // 输出日期部分
}
// 2023-06-01
// 2023-06-02
// 2023-06-03
// 2023-06-04
// 2023-06-05遍历月份
// 遍历两个日期之间的每个月的第一天
function* eachMonthOfInterval(startDate, endDate) {
let currentDate = new Date(startDate);
// 设置为当月的第一天
currentDate.setDate(1);
currentDate.setHours(0, 0, 0, 0);
const end = new Date(endDate);
end.setHours(0, 0, 0, 0);
while (currentDate <= end) {
yield new Date(currentDate);
currentDate.setMonth(currentDate.getMonth() + 1);
}
}
// 使用示例
const start = new Date(2023, 0, 15); // 2023年1月15日
const end = new Date(2023, 5, 15); // 2023年6月15日
for (const month of eachMonthOfInterval(start, end)) {
console.log(month.toISOString().split('T')[0]); // 输出日期部分
}
// 2023-01-01
// 2023-02-01
// 2023-03-01
// 2023-04-01
// 2023-05-01
// 2023-06-01实际应用示例
1. 日期选择器范围验证
// 验证日期选择范围
function validateDateRange(startDate, endDate, minDays, maxDays) {
// 计算选择的天数
const daysDiff = getDaysDiff(startDate, endDate);
// 验证最小天数
if (minDays !== undefined && daysDiff < minDays) {
return {
valid: false,
message: `选择的日期范围不能少于${minDays}天`
};
}
// 验证最大天数
if (maxDays !== undefined && daysDiff > maxDays) {
return {
valid: false,
message: `选择的日期范围不能超过${maxDays}天`
};
}
return { valid: true };
}
// 使用示例
const checkIn = new Date(2023, 5, 1);
const checkOut = new Date(2023, 5, 10);
// 验证酒店预订（最少1晚，最多14晚）
const validation = validateDateRange(checkIn, checkOut, 1, 14);
console.log(validation); // { valid: true }
// 验证长期租赁（最少30天）
const longStayValidation = validateDateRange(checkIn, checkOut, 30);
console.log(longStayValidation); // { valid: false, message: "选择的日期范围不能少于30天" }2. 日历视图生成
// 生成月历视图数据
function generateCalendarMonth(year, month) {
// 创建指定月份的第一天
const firstDayOfMonth = new Date(year, month, 1);
// 获取月份的天数
const daysInMonth = new Date(year, month + 1, 0).getDate();
// 获取月份第一天是星期几（0-6，0表示周日）
const firstDayOfWeek = firstDayOfMonth.getDay();
// 生成日历网格（6行7列）
const calendarGrid = [];
let currentDay = 1;
// 遍历6周
for (let week = 0; week < 6; week++) {
const weekDays = [];
// 遍历每周的7天
for (let day = 0; day < 7; day++) {
// 第一周前面的空白和最后一周后面的空白
if ((week === 0 && day < firstDayOfWeek) || currentDay > daysInMonth) {
weekDays.push(null);
} else {
weekDays.push(new Date(year, month, currentDay));
currentDay++;
}
}
calendarGrid.push(weekDays);
// 如果已经生成完所有天数，提前结束
if (currentDay > daysInMonth) {
break;
}
}
return calendarGrid;
}
// 使用示例
const calendarData = generateCalendarMonth(2023, 5); // 2023年6月
console.log(calendarData);
// 输出一个二维数组，表示日历网格3. 工作日计算器（排除节假日）
// 计算工作日，排除周末和指定的节假日
function getBusinessDaysDiff(startDate, endDate, holidays = []) {
// 转换holidays为Date对象数组并格式化为YYYY-MM-DD字符串
const holidayStrings = holidays.map(holiday => {
const date = new Date(holiday);
return `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, '0')}-${String(date.getDate()).padStart(2, '0')}`;
});
// 确保startDate早于endDate
let start = new Date(Math.min(startDate, endDate));
let end = new Date(Math.max(startDate, endDate));
// 设置为当天的开始时间
start.setHours(0, 0, 0, 0);
end.setHours(0, 0, 0, 0);
let businessDays = 0;
let current = new Date(start);
// 遍历每一天
while (current <= end) {
const dayOfWeek = current.getDay();
// 检查是否为工作日（不是周末）且不是节假日
const dateString = `${current.getFullYear()}-${String(current.getMonth() + 1).padStart(2, '0')}-${String(current.getDate()).padStart(2, '0')}`;
if (dayOfWeek !== 0 && dayOfWeek !== 6 && !holidayStrings.includes(dateString)) {
businessDays++;
}
// 前进一天
current.setDate(current.getDate() + 1);
}
return businessDays;
}
// 使用示例
const start = new Date(2023, 0, 1); // 2023年1月1日
const end = new Date(2023, 0, 10); // 2023年1月10日
// 定义节假日
const holidays = [
new Date(2023, 0, 2), // 元旦假期
new Date(2023, 0, 3) // 元旦假期
];
console.log(getBusinessDaysDiff(start, end, holidays)); // 5（排除了2个周末和2个节假日）4. 日期分组统计
// 按日期范围分组统计数据
function groupDataByDateRange(data, dateField, interval = 'day') {
// 确保数据是数组
if (!Array.isArray(data) || data.length === 0) {
return [];
}
// 按日期字段排序
const sortedData = [...data].sort((a, b) => {
return new Date(a[dateField]) - new Date(b[dateField]);
});
// 获取日期范围
const startDate = new Date(sortedData[0][dateField]);
const endDate = new Date(sortedData[sortedData.length - 1][dateField]);
// 根据间隔生成日期范围
const dateRanges = [];
if (interval === 'day') {
// 按天分组
for (const date of eachDayOfInterval(startDate, endDate)) {
const nextDay = new Date(date);
nextDay.setDate(nextDay.getDate() + 1);
dateRanges.push({
start: date,
end: nextDay,
label: date.toISOString().split('T')[0],
data: []
});
}
} else if (interval === 'week') {
// 按周分组
let currentDate = startOfWeek(startDate);
while (currentDate <= endDate) {
const weekEnd = endOfWeek(currentDate);
dateRanges.push({
start: currentDate,
end: new Date(weekEnd.getTime() + 1), // 加1毫秒以包含结束日期
label: `${currentDate.toISOString().split('T')[0]} ~ ${weekEnd.toISOString().split('T')[0]}`,
data: []
});
currentDate = new Date(weekEnd);
currentDate.setDate(currentDate.getDate() + 1);
}
} else if (interval === 'month') {
// 按月分组
for (const date of eachMonthOfInterval(startDate, endDate)) {
const monthEnd = endOfMonth(date);
dateRanges.push({
start: date,
end: new Date(monthEnd.getTime() + 1), // 加1毫秒以包含结束日期
label: `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, '0')}`,
data: []
});
}
}
// 将数据分配到对应的日期范围
for (const item of sortedData) {
const itemDate = new Date(item[dateField]);
for (const range of dateRanges) {
if (itemDate >= range.start && itemDate < range.end) {
range.data.push(item);
break;
}
}
}
return dateRanges;
}
// 使用示例
const salesData = [
{ id: 1, date: '2023-06-01', amount: 100 },
{ id: 2, date: '2023-06-01', amount: 200 },
{ id: 3, date: '2023-06-02', amount: 150 },
{ id: 4, date: '2023-06-05', amount: 300 },
{ id: 5, date: '2023-06-10', amount: 250 }
];
// 按天分组
const dailyGroups = groupDataByDateRange(salesData, 'date', 'day');
console.log(dailyGroups);
// 按月分组
const monthlyGroups = groupDataByDateRange(salesData, 'date', 'month');
console.log(monthlyGroups);常见问题和最佳实践
1. 处理时区问题
// 获取当前时区偏移（分钟）
function getTimezoneOffset() {
return new Date().getTimezoneOffset();
}
// 将本地日期转换为UTC日期
function toUTC(date) {
return new Date(date.getTime() + date.getTimezoneOffset() * 60000);
}
// 将UTC日期转换为本地日期
function toLocalTime(date) {
return new Date(date.getTime() - date.getTimezoneOffset() * 60000);
}
// 创建特定时区的日期
function createDateInTimezone(isoString, timezone) {
// 使用Intl.DateTimeFormat获取时区偏移
const formatter = new Intl.DateTimeFormat('en-US', {
timeZone: timezone,
timeZoneName: 'short'
});
// 解析ISO字符串为UTC日期
const date = new Date(isoString);
// 获取格式化后的字符串，包含时区信息
const formattedDate = formatter.format(date);
// 这只是一个简化的示例，实际上需要更复杂的逻辑来处理时区转换
return date;
}
// 使用示例
const now = new Date();
console.log('本地时间:', now.toString());
console.log('UTC时间:', now.toUTCString());
// 注意：JavaScript的Date对象总是根据用户的本地时区显示
// 要正确处理不同时区的日期，建议使用专门的库如date-fns-tz或moment-timezone2. 处理闰年
// 检查是否为闰年
function isLeapYear(year) {
// 能被4整除但不能被100整除，或者能被400整除
return (year % 4 === 0 && year % 100 !== 0) || (year % 400 === 0);
}
// 获取指定年月的天数
function getDaysInMonth(year, month) {
// 月份从0开始（0表示一月）
return new Date(year, month + 1, 0).getDate();
}
// 使用示例
console.log(isLeapYear(2020)); // true
console.log(isLeapYear(2021)); // false
console.log(isLeapYear(2000)); // true（能被400整除）
console.log(isLeapYear(1900)); // false（能被100整除但不能被400整除）
// 获取2月的天数
console.log(getDaysInMonth(2020, 1)); // 29（闰年）
console.log(getDaysInMonth(2021, 1)); // 28（非闰年）3. 处理日期溢出
// 安全地设置日期，处理月末溢出
function safeSetDate(date, year, month, day) {
const result = new Date(date);
// 先设置年和月
result.setFullYear(year);
result.setMonth(month);
// 获取当月的最大天数
const maxDays = getDaysInMonth(year, month);
// 确保日期不超过当月的最大天数
const safeDay = Math.min(day, maxDays);
result.setDate(safeDay);
return result;
}
// 使用示例
const date = new Date(2023, 0, 31); // 2023年1月31日
// 安全地设置为2月（处理2月没有31日的情况）
const febDate = safeSetDate(date, 2023, 1, date.getDate());
console.log(febDate); // 2023年2月28日
// 安全地设置为4月（4月有30日）
const aprDate = safeSetDate(date, 2023, 3, date.getDate());
console.log(aprDate); // 2023年4月30日4. 日期格式化最佳实践
// 使用Intl.DateTimeFormat进行本地化格式化
function formatDate(date, options = {}, locale = 'zh-CN') {
return new Intl.DateTimeFormat(locale, options).format(date);
}
// 使用示例
const date = new Date(2023, 5, 15, 14, 30, 25);
// 短日期格式
console.log(formatDate(date, { dateStyle: 'short' }));
// "2023/6/15"
// 长日期格式
console.log(formatDate(date, { dateStyle: 'long' }));
// "2023年6月15日"
// 日期和时间
console.log(formatDate(date, {
dateStyle: 'medium',
timeStyle: 'medium'
}));
// "2023年6月15日 14:30:25"
// 自定义格式
console.log(formatDate(date, {
year: 'numeric',
month: 'long',
day: 'numeric',
weekday: 'long',
hour: '2-digit',
minute: '2-digit'
}));
// "2023年6月15日星期四 14:30"
// 不同地区的格式
console.log(formatDate(date, { dateStyle: 'full' }, 'en-US'));
// "Thursday, June 15, 2023"
console.log(formatDate(date, { dateStyle: 'full' }, 'de-DE'));
// "Donnerstag, 15. Juni 2023"5. 性能优化
// 避免在循环中重复创建Date对象
function badPerformance(dates) {
let result = 0;
for (let i = 0; i < 1000; i++) {
for (const dateStr of dates) {
// 每次迭代都创建新的Date对象，性能差
const date = new Date(dateStr);
result += date.getTime();
}
}
return result;
}
// 优化：预先创建Date对象
function goodPerformance(dates) {
let result = 0;
// 预先创建Date对象
const dateObjects = dates.map(dateStr => new Date(dateStr));
for (let i = 0; i < 1000; i++) {
for (const date of dateObjects) {
result += date.getTime();
}
}
return result;
}
// 使用示例
const dates = ['2023-01-01', '2023-02-01', '2023-03-01'];
console.time('Bad Performance');
badPerformance(dates);
console.timeEnd('Bad Performance');
console.time('Good Performance');
goodPerformance(dates);
console.timeEnd('Good Performance');
// 优化版本通常会快很多日期库比较
虽然原生JavaScript的Date对象功能已经相当强大，但在处理复杂的日期计算时，使用专门的日期库可以提高开发效率和代码可读性。
1. date-fns
// 使用date-fns库的示例（需要先安装：npm install date-fns）
import {
addDays,
differenceInDays,
format,
isWithinInterval
} from 'date-fns';
const today = new Date();
const nextWeek = addDays(today, 7);
// 格式化日期
console.log(format(today, 'yyyy-MM-dd')); // "2023-06-15"
// 计算天数差
console.log(differenceInDays(nextWeek, today)); // 7
// 检查日期是否在范围内
const isInRange = isWithinInterval(
new Date(2023, 5, 20),
{ start: today, end: nextWeek }
);
console.log(isInRange); // true或false，取决于当前日期2. Day.js
// 使用Day.js库的示例（需要先安装：npm install dayjs）
import dayjs from 'dayjs';
const today = dayjs();
const nextWeek = today.add(7, 'day');
// 格式化日期
console.log(today.format('YYYY-MM-DD')); // "2023-06-15"
// 计算天数差
console.log(nextWeek.diff(today, 'day')); // 7
// 比较日期
console.log(today.isBefore(nextWeek)); // true
console.log(today.isAfter(nextWeek)); // false3. Luxon
// 使用Luxon库的示例（需要先安装：npm install luxon）
import { DateTime, Interval } from 'luxon';
const today = DateTime.local();
const nextWeek = today.plus({ days: 7 });
// 格式化日期
console.log(today.toFormat('yyyy-MM-dd')); // "2023-06-15"
// 计算天数差
console.log(nextWeek.diff(today, 'days').days); // 7
// 创建时间间隔
const interval = Interval.fromDateTimes(today, nextWeek);
console.log(interval.length('days')); // 7总结
JavaScript的Date对象提供了丰富的功能来进行日期计算和比较：
日期比较：可以使用比较运算符直接比较Date对象，或使用getTime()方法比较时间戳。
日期差值计算：可以计算两个日期之间的毫秒数、天数、工作日数等。
日期加减操作：可以添加或减去天数、月份、年份、小时等。
日期舍入操作：可以获取某一天、某一月或某一年的开始或结束时间。
日期迭代：可以遍历日期范围，生成日期序列。
在处理日期时，需要注意以下几点：
- 月份从0开始（0表示一月，11表示十二月）
- 日期溢出会自动调整（例如，将1月31日加一个月会得到2月28日或29日）
- 时区问题可能导致意外结果
- 闰年需要特殊处理
对于复杂的日期操作，可以考虑使用专门的日期库如date-fns、Day.js或Luxon，它们提供了更丰富的功能和更好的跨浏览器兼容性。
练习
编写一个函数，计算两个日期之间的工作日数量，排除周末和指定的节假日。
实现一个日期范围选择器的验证函数，确保选择的日期范围不超过指定的最大天数。
创建一个函数，生成指定月份的日历视图数据，包括上个月和下个月的溢出日期。
编写一个函数，计算给定日期是一年中的第几天。
实现一个函数，将日期格式化为"x天前"、"x小时前"等相对时间表示。