Fatal编程技术网
  • javascript/
  • 如何在JavaScript中获取两个日期之间的天数？

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

javascript date

如何在JavaScript中获取两个日期之间的天数？,javascript,date,Javascript,Date,如何在JavaScript中获取两个日期之间的天数？例如，在输入框中给定两个日期： <input id="first" value="1/1/2000"/> <input id="second" value="1/1/2001"/> <script> alert(datediff("day", first, second)); // what goes here? </script> 警报（datediff（“天”，第一天，第二天））；/

如何在JavaScript中获取两个日期之间的天数？例如，在输入框中给定两个日期：

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

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


警报（datediff（“天”，第一天，第二天））；//这里有什么？
如何使用from DatePicker小部件？您可以使用它将日期转换为时间戳格式（自1970年1月1日起的毫秒数），然后执行简单的减法。

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

//新日期（“dateString”）依赖于浏览器，不鼓励使用，因此我们将编写
//美国日期格式的简单解析函数（不进行错误检查）
函数解析日期（str）{
var mdy=str.split（'/'）；
返回新日期（mdy[2]，mdy[0]-1，mdy[1]）；
}
函数datediff（第一，第二）{
//取两个日期之间的差值除以每天的毫秒数。
//四舍五入到最接近的整数以处理DST。
返回数学圆（（第二个第一）/（1000*60*60*24））；
}
警报（datediff（parseDate（first.value）、parseDate（second.value））



我会继续讲下去，在里面你会发现一些函数可以为你实现这一点。下面是一个简短的例子：


        <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>




var分钟=1000*60；
var小时=分钟*60；
var天数=小时*24；
var foo_date1=getDateFromFormat（“2009年10月2日”，“M/d/y”）；
var foo_date2=getDateFromFormat（“2009年12月2日”，“M/d/y”）；
var diff_date=数学圆（（foo_date2-foo_date1）/天）；
警报（“差异日期为：“+Diff_date”）；

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


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;
    }
}



我认为解决方案不是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)
    };
}



在撰写本文时，其他答案中只有一个正确地处理了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年10月3日中午12:00太平洋标准时间（UTC-08:00）存储为2013年10月3日上午8:00 UTC，2013年11月3日中午12:00太平洋夏令时（UTC-07:00）存储为2013年11月3日上午7:00 UTC。在这一天，当地时间午夜到午夜仅为UTC的23小时

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


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

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


我建议使用moment.js库（）。它可以正确地处理夏令时，一般来说，使用它非常好

例如：


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



daysBetween(1096580303, 1308713220); // 2455



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

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


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


该方法可在两个日期截断磨机：



var date1=新日期（'2013/11/04 00:00:00'）；
var date2=新日期（'2013/11/04 10:10:10'）//少于1
var start=Math.floor（date1.getTime（）/（3600*24*1000））//天作为整数，从。。
var end=Math.floor（date2.getTime（）/（3600*24*1000））//天作为整数，从。。
var daysDiff=结束-开始；//确切日期
控制台日志（daysDiff）；
日期2=新日期（'2013/11/05 00:00:00'）//1.
var start=Math.floor（date1.getTime（）/（3600*24*1000））//天作为整数，从。。
var end=Math.floor（date2.getTime（）/（3600*24*1000））//天作为整数，从。。
var daysDiff=结束-开始；//确切日期
控制台日志（daysDiff）

Date.prototype.days=函数（to）{
返回Math.abs（Math.floor（to.getTime（）/（3600*24*1000））-Math.floor（this.getTime（）/（3600*24*1000）））
}
控制台日志（新日期（'2014/05/20'）。天（新日期（'2014/05/23'））；//三天

控制台日志（新日期（'2014/05/23'）。天（新日期（'2014/05/20'））；//3天
这可能不是最优雅的解决方案，但我认为它似乎用一段相对简单的代码来回答这个问题。你不能用这样的东西吗


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

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

return dayCount; 
}



这是假设您将日期对象作为参数传递。
最好使用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
是以毫秒为单位的一天。
使用Moment.js



var未来=时刻（'05/02/2015'）；
var开始=力矩（'04/23/2015'）；
var d=future.diff（开始，“天”）；//9
控制台日志（d）

我在Angular上也有同样的问题。我复制是因为他会改写第一个日期。两个日期的时间都必须为00:00：

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));



 /*
* 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;
};



// 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



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");
}



<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>



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;



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



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;
}



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);



function DateDiff(aDate1, aDate2) {
  let dDay = 0;
  this.isBissexto = (aYear) => {
    return (aYear % 4 == 0 && aYear % 100 != 0) || (aYear % 400 == 0);
  };
  this.getDayOfYear = (aDate) => {
    let count = 0;
    for (let m = 0; m < aDate.getUTCMonth(); m++) {
      count += m == 1 ? this.isBissexto(aDate.getUTCFullYear()) ? 29 : 28 : /(3|5|8|10)/.test(m) ? 30 : 31;
    }
    count += aDate.getUTCDate();
    return count;
  };
  this.toDays = () => {
    return dDay;
  };
  (() => {
    let startDate = aDate1.getTime() <= aDate2.getTime() ? new Date(aDate1.toISOString()) : new Date(aDate2.toISOString());
    let endDate = aDate1.getTime() <= aDate2.getTime() ? new Date(aDate2.toISOString()) : new Date(aDate1.toISOString());
    while (startDate.getUTCFullYear() != endDate.getUTCFullYear()) {
      dDay += (this.isBissexto(startDate.getFullYear())? 366 : 365) - this.getDayOfYear(startDate) + 1;
      startDate = new Date(startDate.getUTCFullYear()+1, 0, 1);
    }
    dDay += this.getDayOfYear(endDate) - this.getDayOfYear(startDate);
  })();
}



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);