如何计算两个日期之间的天数？答案

【问题标题】：How to calculate number of days between two dates?如何计算两个日期之间的天数？
【发布时间】：2010-10-07 06:36:32
【问题描述】：

例如，给定输入框中的两个日期：

<input id="first" value="1/1/2000"/>
<input id="second" value="1/1/2001"/>

<script>
  alert(datediff("day", first, second)); // what goes here?
</script>

如何在 JavaScript 中获取两个日期之间的天数？

【问题讨论】：

99% 的用户询问“两个日期之间的天数”的情况，她不明白的是，她试图将苹果与梨进行比较。如果问“日期范围内有多少个日期？”，或者我必须在日历上穿过多少个方格，问题就变得如此简单。这留下了时间和夏令时等问题。由于日期时间数据结构纯属无稽之谈，我们隐含了混淆。没有日期时间之类的东西，有日期，有时间，在性质和行为上都是两个截然不同的对象
对于将差异拆分为（整体）时间单位的函数，请使用stackoverflow.com/a/53092438/3787376 的答案。
我觉得这个问题应该被删除或至少标记为“避免”，因为大多数答案要么不正确，要么依赖于各种库。
@RobG 库是唯一的选择，如果 JavaScript 没有提供正确的内置方法。
@MCEmperor — 几乎没有，top voted answer 只是 3 行代码，其中两行用于解析。

标签： javascript date

【解决方案1】：

这是datediff 的快速而肮脏的实现，作为解决问题中提出的问题的概念证明。它依赖于这样一个事实，即您可以通过减去它们来获得两个日期之间经过的毫秒数，这会将它们强制转换为其原始数值（自 1970 年初以来的毫秒数）。

// new Date("dateString") is browser-dependent and discouraged, so we'll write
// a simple parse function for U.S. date format (which does no error checking)
function parseDate(str) {
    var mdy = str.split('/');
    return new Date(mdy[2], mdy[0]-1, mdy[1]);
}

function datediff(first, second) {
    // Take the difference between the dates and divide by milliseconds per day.
    // Round to nearest whole number to deal with DST.
    return Math.round((second-first)/(1000*60*60*24));
}

alert(datediff(parseDate(first.value), parseDate(second.value)));

<input id="first" value="1/1/2000"/>
<input id="second" value="1/1/2001"/>

您应该知道，“普通”日期 API（名称中不带“UTC”）在用户浏览器的本地时区运行，因此，一般来说，如果您的用户位于您所指定的时区，您可能会遇到问题不要指望，您的代码将不得不处理夏令时转换。您应该仔细阅读 Date 对象及其方法的文档，对于任何更复杂的内容，强烈考虑使用为日期操作提供更安全和更强大 API 的库。

_{此外，出于说明目的，为了简洁起见，sn-p 使用 named access on the window object，但在生产中您应该使用标准化 API，例如 getElementById，或者更有可能使用一些 UI 框架。}

【讨论】：

我认为 Math.trunc() 更合适。以防万一有人使用更精确的 Date 对象（即包括小时、分钟和秒）
作为标记为正确且投票率最高的答案（截至目前），值得评论的是，该答案没有正确处理夏令时。请参阅 Michael Liu 的回答。
parseDate 到底是做什么的？
@osullic - 这个答案使用 Math.round 处理夏令时，但它确实希望只收到日期字符串，而不是日期和时间。
请记住，本例中的日期是美国格式，即 MM/DD/YYYY。如果需要英版，则需要将parseDate方法改为：return new Date(mdy[2], mdy[1], mdy[0]-1);

【解决方案2】：

在撰写本文时，只有一个其他答案正确处理了 DST（夏令时）转换。以下是位于加利福尼亚的系统上的结果：

                                        1/1/2013- 3/10/2013- 11/3/2013-
User       Formula                      2/1/2013  3/11/2013  11/4/2013  Result
---------  ---------------------------  --------  ---------  ---------  ---------
Miles                   (d2 - d1) / N   31        0.9583333  1.0416666  Incorrect
some         Math.floor((d2 - d1) / N)  31        0          1          Incorrect
fuentesjr    Math.round((d2 - d1) / N)  31        1          1          Correct
toloco     Math.ceiling((d2 - d1) / N)  31        1          2          Incorrect

N = 86400000

虽然Math.round 返回正确的结果，但我认为它有点笨拙。相反，通过在 DST 开始或结束时显式考虑 UTC 偏移量的变化，我们可以使用精确算术：

function treatAsUTC(date) {
    var result = new Date(date);
    result.setMinutes(result.getMinutes() - result.getTimezoneOffset());
    return result;
}

function daysBetween(startDate, endDate) {
    var millisecondsPerDay = 24 * 60 * 60 * 1000;
    return (treatAsUTC(endDate) - treatAsUTC(startDate)) / millisecondsPerDay;
}

alert(daysBetween($('#first').val(), $('#second').val()));

说明

JavaScript 日期计算很棘手，因为 Date 对象在内部以 UTC 存储时间，而不是本地时间。例如，2013 年 3 月 10 日上午 12:00 太平洋标准时间 (UTC-08:00) 存储为 2013 年 3 月 10 日上午 8:00 UTC 和 2013 年 3 月 11 日上午 12:00 太平洋夏令时间 ( UTC-07:00) 存储为 2013 年 3 月 11 日上午 7:00 UTC。这一天，当地时间午夜到午夜只有 23 小时（UTC 时间）！

虽然当地时间的一天可以多于或少于 24 小时，但 UTC 的一天总是正好是 24 小时。¹ 上面显示的daysBetween 方法首先利用了这一事实调用treatAsUTC 将本地时间调整为UTC 午夜，然后再进行减法和除法。

^{1. JavaScript 忽略闰秒。}

【讨论】：

不需要使用 UTC，只需将本地时间设置为午夜（或两个日期的值相同）即可。夏令时引入的小数天数最多仅为 ±0.04（在某些地方更少），因此使用 Math.round 进行舍入。 ;-) 依靠 Date 构造函数来解析字符串不是一个好主意。如果您真的想使用 UTC 值，请首先使用 Date.UTC(...) 解析字符串。
@RobG：正如我在回答中所说：“虽然 Math.round 返回正确的结果，但我认为它有点笨拙。相反，通过在 DST 开始或结束时明确考虑 UTC 偏移量的变化，我们可以使用精确的算术。”
实际上，您表示为“不正确”的时间在技术上是正确的。您没有将 DateTimes 更改为 UTC ......您只是更改每个 DateTime 的时间以获得一个人为的整数。四舍五入并不是“笨拙的”……这正是这里的正确方法，因为无论如何这就是您在脑海中所做的事情：您正在四舍五入时间部分（小时，分钟，秒）并试图获得一个整体天数。

【解决方案3】：

获取两个日期之间差异的最简单方法：

var diff = Math.floor((Date.parse(str2) - Date.parse(str1)) / 86400000);

你会得到不同的天数（如果一个或两个都无法解析，则为 NaN）。解析日期以毫秒为单位给出结果，要按天计算，您必须将其除以 24 * 60 * 60 * 1000

如果你想除以天、小时、分钟、秒和毫秒：

function dateDiff( str1, str2 ) {
    var diff = Date.parse( str2 ) - Date.parse( str1 ); 
    return isNaN( diff ) ? NaN : {
        diff : diff,
        ms : Math.floor( diff            % 1000 ),
        s  : Math.floor( diff /     1000 %   60 ),
        m  : Math.floor( diff /    60000 %   60 ),
        h  : Math.floor( diff /  3600000 %   24 ),
        d  : Math.floor( diff / 86400000        )
    };
}

这是我重构的 James 版本：

function mydiff(date1,date2,interval) {
    var second=1000, minute=second*60, hour=minute*60, day=hour*24, week=day*7;
    date1 = new Date(date1);
    date2 = new Date(date2);
    var timediff = date2 - date1;
    if (isNaN(timediff)) return NaN;
    switch (interval) {
        case "years": return date2.getFullYear() - date1.getFullYear();
        case "months": return (
            ( date2.getFullYear() * 12 + date2.getMonth() )
            -
            ( date1.getFullYear() * 12 + date1.getMonth() )
        );
        case "weeks"  : return Math.floor(timediff / week);
        case "days"   : return Math.floor(timediff / day); 
        case "hours"  : return Math.floor(timediff / hour); 
        case "minutes": return Math.floor(timediff / minute);
        case "seconds": return Math.floor(timediff / second);
        default: return undefined;
    }
}

【讨论】：

错误答案。当时钟在夏令时前进时，Math.floor() 会让你失去一天。 Math.round() 在大多数情况下都会给出正确的答案，但在其他答案中也有更好的选择。
@some 你在哪里看到 James 版本？詹姆斯是谁？
@stomy 好像那个版本被删除了-
使用Math.abs 可能会满足您的需求。

【解决方案4】：

我建议使用 moment.js 库 (http://momentjs.com/docs/#/displaying/difference/)。它可以正确处理夏令时，并且通常非常适合使用。

例子：

var start = moment("2013-11-03");
var end = moment("2013-11-04");
end.diff(start, "days")
1

【讨论】：

作为一个警告，虽然 momentjs 很棒，但它是一个很大的依赖项
确实应该是end.diff(start,"days")，尽管编写的代码可以工作，因为开始日期晚于结束日期！

【解决方案5】：

步骤

设置开始日期
设置结束日期
计算差异
将毫秒转换为天

原生 JS

const startDate  = '2020-01-01';
const endDate    = '2020-03-15';

const diffInMs   = new Date(endDate) - new Date(startDate)
const diffInDays = diffInMs / (1000 * 60 * 60 * 24);

使用库

日期-fns

https://date-fns.org/v2.16.1/docs/differenceInDays

const differenceInDays = require('date-fns/differenceInDays');

const startDate  = '2020-01-01';
const endDate    = '2020-03-15';

const diffInDays = differenceInDays(new Date(endDate), new Date(startDate));

卢克森

https://moment.github.io/luxon/docs/class/src/datetime.js~DateTime.html#instance-method-diff

const { DateTime } = require('luxon');

const startDate  = '2020-01-01';
const endDate    = '2020-03-15';

const diffInDays = DateTime.fromISO(endDate).diff(DateTime.fromISO(startDate), 'days').toObject().days;

Moment.js

https://momentjs.com/docs/#/displaying/difference/

const moment = require('moment');

const startDate  = '2020-01-01';
const endDate    = '2020-03-15';

const diffInDays = moment(endDate).diff(moment(startDate), 'days');

RunKit 示例

https://runkit.com/marcobiedermann/5f573e211e85e7001a37ab00

【讨论】：

我很欣赏这样的答案：简短、简单且不需要随机依赖！干杯。
只有我的timeDiffreturned 是否定的？ timeDiff 不应该是 (new Date(endDate)) - (new Date(startDate)); 吗？
@feyisayo-sonubi 取决于您传入的开始和结束日期的顺序。在这个例子中(new Date('2017-11-08')) - (new Date('2017-10-01')) // 3283200000
const timeDiff = +(new Date(start)) - +(new Date(end));
太棒了。虽然我更喜欢return (Date.UTC(yr2, mo2-1, dy2) - Date.UTC(yr1, mo1-1, dy1)) / 86400000;

【解决方案6】：

我会继续使用grab this small utility，您会在其中找到适合您的功能。这是一个简短的例子：

        <script type="text/javascript" src="date.js"></script>
        <script type="text/javascript">
            var minutes = 1000*60;
            var hours = minutes*60;
            var days = hours*24;

            var foo_date1 = getDateFromFormat("02/10/2009", "M/d/y");
            var foo_date2 = getDateFromFormat("02/12/2009", "M/d/y");

            var diff_date = Math.round((foo_date2 - foo_date1)/days);
            alert("Diff date is: " + diff_date );
        </script>

【讨论】：

【解决方案7】：

使用 Moment.js

var future = moment('05/02/2015');
var start = moment('04/23/2015');
var d = future.diff(start, 'days'); // 9
console.log(d);

&lt;script src="https://cdnjs.cloudflare.com/ajax/libs/moment.js/2.17.1/moment-with-locales.min.js"&gt;&lt;/script&gt;

【讨论】：

moment.js 对于 YTD diff counts var now = moment(), yearStart = moment().startOf('year'); var ytdDays = now.diff(yearStart, 'days'); // this can be years, months, weeks, days, hours, minutes, and seconds console.log(ytdDays); 之类的事情真的很方便：momentjs.com

【解决方案8】：

要计算两个给定日期之间的天数，您可以使用以下代码。我在这里使用的日期是 2016 年 1 月 1 日和 2016 年 12 月 31 日

var day_start = new Date("Jan 01 2016");
var day_end = new Date("Dec 31 2016");
var total_days = (day_end - day_start) / (1000 * 60 * 60 * 24);
document.getElementById("demo").innerHTML = Math.round(total_days);

<h3>DAYS BETWEEN GIVEN DATES</h3>
<p id="demo"></p>

【讨论】：

【解决方案9】：

JS 中的日期值是日期时间值。

因此，直接日期计算是不一致的：

(2013-11-05 00:00:00) - (2013-11-04 10:10:10) < 1 day

例如我们需要转换第二个日期：

(2013-11-05 00:00:00) - (2013-11-04 00:00:00) = 1 day

该方法可以截断两个日期的工厂：

var date1 = new Date('2013/11/04 00:00:00');
var date2 = new Date('2013/11/04 10:10:10'); //less than 1
var start = Math.floor(date1.getTime() / (3600 * 24 * 1000)); //days as integer from..
var end = Math.floor(date2.getTime() / (3600 * 24 * 1000)); //days as integer from..
var daysDiff = end - start; // exact dates
console.log(daysDiff);

date2 = new Date('2013/11/05 00:00:00'); //1

var start = Math.floor(date1.getTime() / (3600 * 24 * 1000)); //days as integer from..
var end = Math.floor(date2.getTime() / (3600 * 24 * 1000)); //days as integer from..
var daysDiff = end - start; // exact dates
console.log(daysDiff);

【讨论】：

【解决方案10】：

最好通过使用 UTC 时间来摆脱 DST、Math.ceil、Math.floor 等：

var firstDate = Date.UTC(2015,01,2);
var secondDate = Date.UTC(2015,04,22);
var diff = Math.abs((firstDate.valueOf() 
    - secondDate.valueOf())/(24*60*60*1000));

这个例子给出了 109 天的差异。 24*60*60*1000 是以毫秒为单位的一天。

【讨论】：

值得补充的是，如果您想要 UTC 中的当前日期，您可以这样做：var now = new Date(); var utcNow = Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate())

【解决方案11】：

试试这个

let today = new Date().toISOString().slice(0, 10)

const startDate  = '2021-04-15';
const endDate    = today;

const diffInMs   = new Date(endDate) - new Date(startDate)
const diffInDays = diffInMs / (1000 * 60 * 60 * 24);


alert( diffInDays  );

【讨论】：

【解决方案12】：

可以使用以下公式计算跨越不同 TZ 的两个日期之间的完整证明天数差异：

var start = new Date('10/3/2015');
var end = new Date('11/2/2015');
var days = (end - start) / 1000 / 60 / 60 / 24;
console.log(days);
// actually its 30 ; but due to daylight savings will show 31.0xxx
// which you need to offset as below
days = days - (end.getTimezoneOffset() - start.getTimezoneOffset()) / (60 * 24);
console.log(days);

【讨论】：

这是最正确的答案，你要考虑夏令时！谢谢

【解决方案13】：

当我想在两个日期进行一些计算时发现了这个问题，但日期有小时和分钟值，我修改了@michael-liu 的答案以满足我的要求，它通过了我的测试。

差异天数 2012-12-31 23:00 和 2013-01-01 01:00 应该等于 1。（2 小时） 2012-12-31 01:00 和 2013-01-01 23:00 的差异天数应等于 1。（46 小时）

function treatAsUTC(date) {
    var result = new Date(date);
    result.setMinutes(result.getMinutes() - result.getTimezoneOffset());
    return result;
}

var millisecondsPerDay = 24 * 60 * 60 * 1000;
function diffDays(startDate, endDate) {
    return Math.floor(treatAsUTC(endDate) / millisecondsPerDay) - Math.floor(treatAsUTC(startDate) / millisecondsPerDay);
}

【讨论】：

【解决方案14】：

这可能不是最优雅的解决方案，但我认为它似乎用相对简单的代码回答了这个问题。你不能用这样的东西吗：

function dayDiff(startdate, enddate) {
  var dayCount = 0;

  while(enddate >= startdate) {
    dayCount++;
    startdate.setDate(startdate.getDate() + 1);
  }

return dayCount; 
}

这是假设您将日期对象作为参数传递。

【讨论】：

最简单的解决方案总是最好的解决方案。希望我能投票 +100

【解决方案15】：

var start= $("#firstDate").datepicker("getDate");
var end= $("#SecondDate").datepicker("getDate");
var days = (end- start) / (1000 * 60 * 60 * 24);
 alert(Math.round(days));

jsfiddle 示例:)

【讨论】：

这就是我要找的。谢谢

【解决方案16】：

我认为解决方案不正确 100% 我会使用 ceil 而不是 floor，round 可以，但它不是正确的操作。

function dateDiff(str1, str2){
    var diff = Date.parse(str2) - Date.parse(str1); 
    return isNaN(diff) ? NaN : {
        diff: diff,
        ms: Math.ceil(diff % 1000),
        s: Math.ceil(diff / 1000 % 60),
        m: Math.ceil(diff / 60000 % 60),
        h: Math.ceil(diff / 3600000 % 24),
        d: Math.ceil(diff / 86400000)
    };
}

【讨论】：

天可以超过 24 小时，分钟可以超过 60 秒。在这些情况下，使用 Math.ceil() 会多计。

【解决方案17】：

在 DatePicker 小部件中使用 formatDate 怎么样？您可以使用它来转换时间戳格式的日期（自 1970 年 1 月 1 日以来的毫秒数），然后进行简单的减法。

【讨论】：

【解决方案18】：

function timeDifference(date1, date2) {
  var oneDay = 24 * 60 * 60; // hours*minutes*seconds
  var oneHour = 60 * 60; // minutes*seconds
  var oneMinute = 60; // 60 seconds
  var firstDate = date1.getTime(); // convert to milliseconds
  var secondDate = date2.getTime(); // convert to milliseconds
  var seconds = Math.round(Math.abs(firstDate - secondDate) / 1000); //calculate the diffrence in seconds
  // the difference object
  var difference = {
    "days": 0,
    "hours": 0,
    "minutes": 0,
    "seconds": 0,
  }
  //calculate all the days and substract it from the total
  while (seconds >= oneDay) {
    difference.days++;
    seconds -= oneDay;
  }
  //calculate all the remaining hours then substract it from the total
  while (seconds >= oneHour) {
    difference.hours++;
    seconds -= oneHour;
  }
  //calculate all the remaining minutes then substract it from the total 
  while (seconds >= oneMinute) {
    difference.minutes++;
    seconds -= oneMinute;
  }
  //the remaining seconds :
  difference.seconds = seconds;
  //return the difference object
  return difference;
}
console.log(timeDifference(new Date(2017,0,1,0,0,0),new Date()));

【讨论】：

能否请您为您的答案添加更多上下文。仅代码的答案很难理解。如果您可以在帖子中添加更多信息，这将对提问者和未来的读者都有帮助。
我想编辑，但遇到错误我可以提交编辑:( .
@N.Belhadj 您可以用简单的 div 和 mod (%) 操作替换所有这些 while 循环

【解决方案19】：

Date.prototype.days = function(to) {
  return Math.abs(Math.floor(to.getTime() / (3600 * 24 * 1000)) - Math.floor(this.getTime() / (3600 * 24 * 1000)))
}


console.log(new Date('2014/05/20').days(new Date('2014/05/23'))); // 3 days

console.log(new Date('2014/05/23').days(new Date('2014/05/20'))); // 3 days

【讨论】：

【解决方案20】：

简单、轻松、精致。此函数将每 1 秒调用一次以更新时间。

const year = (new Date().getFullYear());
const bdayDate = new Date("04,11,2019").getTime(); //mmddyyyy

// countdown
let timer = setInterval(function () {

    // get today's date
    const today = new Date().getTime();

    // get the difference
    const diff = bdayDate - today;

    // math
    let days = Math.floor(diff / (1000 * 60 * 60 * 24));
    let hours = Math.floor((diff % (1000 * 60 * 60 * 24)) / (1000 * 60 * 60));
    let minutes = Math.floor((diff % (1000 * 60 * 60)) / (1000 * 60));
    let seconds = Math.floor((diff % (1000 * 60)) / 1000);

}, 1000);

【讨论】：

【解决方案21】：

如果你有两个 unix 时间戳，你可以使用这个函数（为了清楚起见，稍微详细一点）：

// Calculate number of days between two unix timestamps
// ------------------------------------------------------------
var daysBetween = function(timeStampA, timeStampB) {
    var oneDay = 24 * 60 * 60 * 1000; // hours * minutes * seconds * milliseconds
    var firstDate = new Date(timeStampA * 1000);
    var secondDate = new Date(timeStampB * 1000);
    var diffDays = Math.round(Math.abs((firstDate.getTime() - secondDate.getTime())/(oneDay)));
    return diffDays;
};

例子：

daysBetween(1096580303, 1308713220); // 2455

【讨论】：

【解决方案22】：

使用毫秒时要小心。

date.getTime() 返回毫秒，以毫秒为单位的数学运算需要包含

夏令时 (DST)
检查两个日期是否具有相同的时间（小时、分钟、秒、毫秒）
确定需要什么天数差异行为：2016 年 9 月 19 日 - 2016 年 9 月 29 日 = 1 天或 2 天差异？

上面评论中的示例是迄今为止我找到的最佳解决方案 https://stackoverflow.com/a/11252167/2091095 。但是，如果您想计算所涉及的所有天数，请对其结果使用 +1。

function treatAsUTC(date) {
    var result = new Date(date);
    result.setMinutes(result.getMinutes() - result.getTimezoneOffset());
    return result;
}

function daysBetween(startDate, endDate) {
    var millisecondsPerDay = 24 * 60 * 60 * 1000;
    return (treatAsUTC(endDate) - treatAsUTC(startDate)) / millisecondsPerDay;
}

var diff = daysBetween($('#first').val(), $('#second').val()) + 1;

【讨论】：

【解决方案23】：

我在 Angular 中遇到了同样的问题。我做副本，因为否则他会覆盖第一次约会。两个日期都必须有时间 00:00:00（显然）

 /*
* Deze functie gebruiken we om het aantal dagen te bereken van een booking.
* */
$scope.berekenDagen = function ()
{
    $scope.booking.aantalDagen=0;

    /*De loper is gelijk aan de startdag van je reservatie.
     * De copy is nodig anders overschijft angular de booking.van.
     * */
    var loper = angular.copy($scope.booking.van);

    /*Zolang de reservatie beschikbaar is, doorloop de weekdagen van je start tot einddatum.*/
    while (loper < $scope.booking.tot) {
        /*Tel een dag op bij je loper.*/
        loper.setDate(loper.getDate() + 1);
        $scope.booking.aantalDagen++;
    }

    /*Start datum telt natuurlijk ook mee*/
    $scope.booking.aantalDagen++;
    $scope.infomsg +=" aantal dagen: "+$scope.booking.aantalDagen;
};

【讨论】：

【解决方案24】：

我使用下面的代码来试验新闻帖子的发布日期功能。我根据发布日期和当前日期计算分钟或小时或天或年。

var startDate= new Date("Mon Jan 01 2007 11:00:00");
var endDate  =new Date("Tue Jan 02 2007 12:50:00");
var timeStart = startDate.getTime();
var timeEnd = endDate.getTime();
var yearStart = startDate.getFullYear();
var yearEnd   = endDate.getFullYear();
if(yearStart == yearEnd)
 {
  var hourDiff = timeEnd - timeStart; 
  var secDiff = hourDiff / 1000;
  var minDiff = hourDiff / 60 / 1000; 
  var hDiff = hourDiff / 3600 / 1000; 
  var myObj = {};
  myObj.hours = Math.floor(hDiff);
  myObj.minutes = minDiff  
  if(myObj.hours >= 24)
   {
    console.log(Math.floor(myObj.hours/24) + "day(s) ago")
   } 
 else if(myObj.hours>0)
  {
   console.log(myObj.hours +"hour(s) ago")
  }
 else
  {
   console.log(Math.abs(myObj.minutes) +"minute(s) ago")
  }
}
else
{
var yearDiff = yearEnd - yearStart;
console.log( yearDiff +" year(s) ago");
}

【讨论】：

请解释你的代码，你解决了问题，只是粘贴代码被认为是一个错误的答案。
虽然此代码可以回答问题，但提供有关如何和/或 为什么 解决问题的附加上下文将改善答案的长期价值。
感谢@MarcoScabbiolo，@Michael Parker 的cmets。由于我在回答方面是Stackoverflow 的新手，所以我不知道应该如何提供解决方案

【解决方案25】：

如果你想要一个带日期的 DateArray，试试这个：

<script>
        function getDates(startDate, stopDate) {
        var dateArray = new Array();
        var currentDate = moment(startDate);
        dateArray.push( moment(currentDate).format('L'));

        var stopDate = moment(stopDate);
        while (dateArray[dateArray.length -1] != stopDate._i) {
            dateArray.push( moment(currentDate).format('L'));
            currentDate = moment(currentDate).add(1, 'days');
        }
        return dateArray;
      }
</script>

DebugSnippet

【讨论】：

【解决方案26】：

计算两个日期之间的天数的简单方法是删除它们的两个时间部分，即将小时、分钟、秒和毫秒设置为 0，然后减去它们的时间，并用一天的毫秒数来计算。

var firstDate= new Date(firstDate.setHours(0,0,0,0));
var secondDate= new Date(secondDate.setHours(0,0,0,0));
var timeDiff = firstDate.getTime() - secondDate.getTime();
var diffDays =timeDiff / (1000 * 3600 * 24);

【讨论】：

您的解决方案的问题是，您假设 firstDate 和 secondDate 是日期，那么无需再次将它们更改为日期，如果它们不是日期 * 不是）你会在 setHours 上出现错误。要更正此问题，您需要将 setHours 移出 new Date

【解决方案27】：

function formatDate(seconds, dictionary) {
    var foo = new Date;
    var unixtime_ms = foo.getTime();
    var unixtime = parseInt(unixtime_ms / 1000);
    var diff = unixtime - seconds;
    var display_date;
    if (diff <= 0) {
        display_date = dictionary.now;
    } else if (diff < 60) {
        if (diff == 1) {
            display_date = diff + ' ' + dictionary.second;
        } else {
            display_date = diff + ' ' + dictionary.seconds;
        }
    } else if (diff < 3540) {
        diff = Math.round(diff / 60);
        if (diff == 1) {
            display_date = diff + ' ' + dictionary.minute;
        } else {
            display_date = diff + ' ' + dictionary.minutes;
        }
    } else if (diff < 82800) {
        diff = Math.round(diff / 3600);
        if (diff == 1) {
            display_date = diff + ' ' + dictionary.hour;
        } else {
            display_date = diff + ' ' + dictionary.hours;
        }
    } else {
        diff = Math.round(diff / 86400);
        if (diff == 1) {
            display_date = diff + ' ' + dictionary.day;
        } else {
            display_date = diff + ' ' + dictionary.days;
        }
    }
    return display_date;
}

【讨论】：

【解决方案28】：

我从其他答案中获得了一些灵感，并使输入具有自动卫生功能。我希望这可以作为对其他答案的改进。

//use best practices by labeling your constants.
let MS_PER_SEC = 1000
  , SEC_PER_HR = 60 * 60
  , HR_PER_DAY = 24
  , MS_PER_DAY = MS_PER_SEC * SEC_PER_HR * HR_PER_DAY
;

//let's assume we get Date objects as arguments, otherwise return 0.
function dateDiffInDays(date1, date2) {
    if (!date1 || !date2) {
      return 0;
    }
    return Math.round((date2.getTime() - date1.getTime()) / MS_PER_DAY);
}

// new Date("dateString") is browser-dependent and discouraged, so we'll write
// a simple parse function for U.S. date format. (by @Miles)
function parseDate(str) {
    if (str && str.length > 7 && str.length < 11) {
      let mdy = str.split('/');
      return new Date(mdy[2], mdy[0]-1, mdy[1]);
    }
    return null;
}

function calcInputs() {
  let date1 = document.getElementById("date1")
    , date2 = document.getElementById("date2")
    , resultSpan = document.getElementById("result")
  ;
  if (date1 && date2 && resultSpan) {
    //remove non-date characters
    let date1Val = date1.value.replace(/[^\d\/]/g,'')
      , date2Val = date2.value.replace(/[^\d\/]/g,'')
      , result = dateDiffInDays(parseDate(date1Val), parseDate(date2Val))
    ;
    date1.value = date1Val;
    date2.value = date2Val;
    resultSpan.innerHTML = result + " days";
  }
}
window.onload = function() { calcInputs(); };

//some code examples
console.log(dateDiffInDays(parseDate("1/15/2019"), parseDate("1/30/2019")));
console.log(dateDiffInDays(parseDate("1/15/2019"), parseDate("2/30/2019")));
console.log(dateDiffInDays(parseDate("1/15/2000"), parseDate("1/15/2019")));

<input id="date1" type="text" value="1/1/2000" size="6" onkeyup="calcInputs();" />
<input id="date2" type="text" value="1/1/2019" size="6" onkeyup="calcInputs();"/>
Result: <span id="result"></span>

【讨论】：

我没有使用 'date1.getTime()' 和 'date2.getTime()' 我使用 'Date.UTC' 来防止不属于同一天节约时间的日期之间的差异（即2021 年 3 月 10 日和 2021 年 3 月 16 日）以下功能可能会有所帮助：function getUTCTime(date) { // If use 'Date.getTime()' it doesn't compute the right amount of days // if there is a 'day saving time' change between dates return Date.UTC(date.getFullYear(), date.getMonth(), date.getDate()); }

【解决方案29】：

单线和小号

const diff=(e,t)=>Math.floor((new Date(e).getTime()-new Date(t).getTime())/1000*60*60*24);

// or

const diff=(e,t)=>Math.floor((new Date(e).getTime()-new Date(t).getTime())/86400000);

// or

const diff=(e,t)=>Math.floor((new Date(e).getTime()-new Date(t).getTime())/864e5);

// or

const diff=(e,t)=>Math.floor((new Date(e)-new Date(t))/864e5);

// or

const diff=(a,b)=>(new Date(a)-new Date(b))/864e5|0; 

// use
diff('1/1/2001', '1/1/2000')

对于打字稿

const diff=(e,t)=>Math.floor((new Date(e).getTime()-new Date(t).getTime())/86400000);

【讨论】：

【解决方案30】：

我最近有同样的问题，我来自 Java 世界，我立即开始搜索 JavaScript 的 JSR 310 实现。 JSR 310 是 Java 的日期和时间 API（标准从 Java 8 开始提供）。我认为 API 设计得非常好。

幸运的是，有一个 Javascript 的直接端口，称为js-joda。

首先，在<head>中包含js-joda：

<script
    src="https://cdnjs.cloudflare.com/ajax/libs/js-joda/1.11.0/js-joda.min.js"
    integrity="sha512-piLlO+P2f15QHjUv0DEXBd4HvkL03Orhi30Ur5n1E4Gk2LE4BxiBAP/AD+dxhxpW66DiMY2wZqQWHAuS53RFDg=="
    crossorigin="anonymous"></script>

然后简单地这样做：

let date1 = JSJoda.LocalDate.of(2020, 12, 1);
let date2 = JSJoda.LocalDate.of(2021, 1, 1);
let daysBetween = JSJoda.ChronoUnit.DAYS.between(date1, date2);

现在daysBetween 包含之间的天数。请注意，结束日期是独有的。

【讨论】：