Wie erhalte ich die Anzahl der Tage zwischen zwei Daten in JavaScript?

Wie erhalte ich die Anzahl der Tage zwischen zwei Daten in JavaScript? Beispiel: Geben Sie zwei Daten in Eingabefeldern an:

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

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

Hier ist eine schnelle und schmutzige Implementierung von datediff, als Proof of Concept, um das in der Frage dargestellte Problem zu lösen. Es beruht auf der Tatsache, dass Sie die verstrichenen Millisekunden zwischen zwei Daten erhalten können, indem Sie sie subtrahieren, wodurch sie in ihren primitiven Zahlenwert (Millisekunden seit Anfang 1970) gezwungen werden.

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

Sie sollten sich bewusst sein, dass die "normalen" Datums-APIs (ohne "UTC" im Namen) in der lokalen Zeitzone des Browsers des Benutzers ausgeführt werden. Daher können im Allgemeinen Probleme auftreten, wenn sich Ihr Benutzer in einer Zeitzone befindet, die Sie nicht kennen Erwarten Sie, und Ihr Code muss sich mit Übergängen der Sommerzeit befassen. Sie sollten die Dokumentation für das Date-Objekt und seine Methoden sorgfältig lesen und für kompliziertere Zwecke die Verwendung einer Bibliothek in Betracht ziehen, die sicherere und leistungsfähigere APIs für die Datumsmanipulation bietet.

• Zahlen und Daten - MDN JavaScript-Handbuch
• Date - MDN-JavaScript-Referenz

_{Zur Veranschaulichung verwendet das Snippet derwindow Kürze halber einen benannten Zugriff auf das Objekt. In der Produktion sollten Sie jedoch standardisierte APIs wie getElementById oder wahrscheinlicher ein UI-Framework verwenden.}

Zum jetzigen Zeitpunkt behandelt nur eine der anderen Antworten die DST-Übergänge (Sommerzeit) korrekt. Hier sind die Ergebnisse eines Systems in Kalifornien:

                                        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

Obwohl Math.rounddie korrekten Ergebnisse zurückgegeben werden, finde ich es etwas klobig. Stattdessen können wir die exakte Arithmetik verwenden, indem wir Änderungen am UTC-Offset explizit berücksichtigen, wenn die Sommerzeit beginnt oder endet:

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

Erläuterung

JavaScript-Datumsberechnungen sind schwierig, da DateObjekte Zeiten intern in UTC und nicht in Ortszeit speichern. Beispielsweise wird die pazifische Standardzeit 3/10/2013 um 12:00 Uhr (UTC-08: 00) als 3/10/2013 8:00 UTC und die 3/11/2013 12:00 Uhr pazifische Sommerzeit (UTC-08: 00) gespeichert. UTC-07: 00) wird als 11.03.2013 7:00 UTC gespeichert. An diesem Tag beträgt die Ortszeit von Mitternacht bis Mitternacht in UTC nur 23 Stunden!

Obwohl ein Tag in der Ortszeit mehr oder weniger als 24 Stunden haben kann, beträgt ein Tag in UTC immer genau 24 Stunden. ¹ Die daysBetweenoben gezeigte Methode nutzt diese Tatsache aus, indem sie zuerst aufruft treatAsUTC, um beide Ortszeiten auf Mitternacht UTC einzustellen, bevor sie subtrahiert und dividiert wird.

^{1. JavaScript ignoriert Schaltsekunden.}

Der einfachste Weg, um den Unterschied zwischen zwei Daten zu ermitteln:

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

Sie erhalten die Differenztage (oder NaN, wenn einer oder beide nicht analysiert werden konnten). Das Analysedatum gab das Ergebnis in Millisekunden an. Um es nach Tag zu erhalten, müssen Sie es durch 24 * 60 * 60 * 1000 teilen

Wenn Sie möchten, dass es durch Tage, Stunden, Minuten, Sekunden und Millisekunden geteilt wird:

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

Hier ist meine überarbeitete Version der James-Version:

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

Ich empfehle die Verwendung der Bibliothek moment.js ( http://momentjs.com/docs/#/displaying/difference/ ). Es geht richtig mit der Sommerzeit um und eignet sich im Allgemeinen hervorragend zum Arbeiten.

Beispiel:

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

Ich würde weitermachen und dieses kleine Dienstprogramm greifen, und darin finden Sie Funktionen für Sie. Hier ist ein kurzes Beispiel:

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

const startDate = '2017-11-08';
const endDate   = '2017-10-01';
const timeDiff  = (new Date(startDate)) - (new Date(endDate));
const days      = timeDiff / (1000 * 60 * 60 * 24)

1. Startdatum einstellen
2. Enddatum einstellen
3. Differenz berechnen
4. Konvertieren Sie Millisekunden in Tage

Update: Ich weiß, dass dies nicht Teil Ihrer Fragen ist, aber im Allgemeinen würde ich nicht empfehlen, eine Datumsberechnung oder -manipulation in Vanille-JavaScript durchzuführen und stattdessen aufgrund vieler Randfälle eine Bibliothek wie date-fns oder moment.js zu verwenden.

Verwenden von Moment.js

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

<script src="https://cdnjs.cloudflare.com/ajax/libs/moment.js/2.17.1/moment-with-locales.min.js"></script>

Datumswerte in JS sind Datums- / Uhrzeitwerte.

Direkte Datumsberechnungen sind also inkonsistent:

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

Zum Beispiel müssen wir das 2. Datum konvertieren:

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

Die Methode könnte darin bestehen, die Mühlen an beiden Daten abzuschneiden:

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

Es ist besser, DST, Math.ceil, Math.floor usw. mithilfe von UTC-Zeiten zu entfernen:

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

Dieses Beispiel gibt einen Unterschied von 109 Tagen. 24*60*60*1000ist ein Tag in Millisekunden.

Um Tage zwischen zwei angegebenen Daten zu berechnen, können Sie den folgenden Code verwenden. Die hier verwendeten Daten sind der 01. Januar 2016 und der 31. Dezember 2016

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>

Mit der folgenden Formel kann eine Differenz der vollständigen Proof-Tage zwischen zwei Daten berechnet werden, die auf verschiedenen TZs liegen:

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

Ich habe diese Frage gefunden, wenn ich an zwei Daten rechnen möchte, aber das Datum hat Stunden- und Minutenwerte. Ich habe die Antwort von @ michael-liu an meine Anforderungen angepasst und sie hat meinen Test bestanden.

diff Tage 2012-12-31 23:00und 2013-01-01 01:00sollte gleich 1. (2 Stunden) diff Tage 2012-12-31 01:00und 2013-01-01 23:00sollte gleich 1. (46 Stunden)

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

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

jsfiddle Beispiel :)

Ich denke, die Lösungen sind nicht 100% korrekt. Ich würde Decke anstelle von Boden verwenden . Rund wird funktionieren, aber es ist nicht die richtige Operation.

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

Was ist mit formatDate aus dem DatePicker-Widget? Sie können es verwenden, um die Daten im Zeitstempelformat (Millisekunden seit dem 01.01.1970) zu konvertieren und dann eine einfache Subtraktion durchzuführen.

Dies ist vielleicht nicht die eleganteste Lösung, aber es scheint die Frage mit einem relativ einfachen Stück Code zu beantworten, denke ich. Kannst du so etwas nicht benutzen:

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

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

return dayCount; 
}

Dies setzt voraus, dass Sie Datumsobjekte als Parameter übergeben.

Wenn Sie zwei Unix-Zeitstempel haben, können Sie diese Funktion verwenden (aus Gründen der Übersichtlichkeit etwas ausführlicher):

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

Beispiel:

daysBetween(1096580303, 1308713220); // 2455

Seien Sie vorsichtig, wenn Sie Millisekunden verwenden .

Date.getTime () gibt Millisekunden zurück, und für die Ausführung von mathematischen Operationen mit Millisekunden muss eingeschlossen werden

• Sommerzeit (DST)
• Überprüfen, ob beide Daten dieselbe Zeit haben (Stunden, Minuten, Sekunden, Millisekunden)
• Stellen Sie sicher, dass das Verhalten der Tage unterschiedlich ist: 19. September 2016 - 29. September 2016 = 1 oder 2 Tage Unterschied?

Das Beispiel aus dem obigen Kommentar ist die beste Lösung, die ich bisher gefunden habe: https://stackoverflow.com/a/11252167/2091095 . Verwenden Sie jedoch +1 für das Ergebnis, wenn Sie möchten, dass alle beteiligten Tage gezählt werden.

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;

Ich hatte das gleiche Problem in Angular. Ich mache die Kopie, weil er sonst das erste Date überschreibt. Beide Daten müssen die Zeit 00:00:00 haben (offensichtlich)

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

Ich habe den folgenden Code verwendet, um die Funktionalität des Buchungsdatums für einen Nachrichtenbeitrag zu testen. Ich berechne die Minute oder Stunde oder den Tag oder das Jahr basierend auf dem Buchungsdatum und dem aktuellen Datum.

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

Wenn Sie ein DateArray mit Datumsangaben haben möchten, versuchen Sie Folgendes:

<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

Die einfache Möglichkeit, Tage zwischen zwei Daten zu berechnen, besteht darin, beide Zeitkomponenten zu entfernen, dh Stunden, Minuten, Sekunden und Millisekunden auf 0 zu setzen, ihre Zeit zu subtrahieren und mit Millisekunden im Wert von einem Tag zu tauchen.

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

Einfach, leicht und raffiniert. Diese Funktion wird alle 1 Sekunde aufgerufen, um die Zeit zu aktualisieren.

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

Eine bessere Lösung von

Zeitteil ignorieren

Es wird 0 zurückgegeben, wenn beide Daten gleich sind.

function dayDiff(firstDate, secondDate) {
  firstDate = new Date(firstDate);
  secondDate = new Date(secondDate);
  if (!isNaN(firstDate) && !isNaN(secondDate)) {
    firstDate.setHours(0, 0, 0, 0); //ignore time part
    secondDate.setHours(0, 0, 0, 0); //ignore time part
    var dayDiff = secondDate - firstDate;
    dayDiff = dayDiff / 86400000; // divide by milisec in one day
    console.log(dayDiff);
  } else {
    console.log("Enter valid date.");
  }
}

$(document).ready(function() {
  $('input[type=datetime]').datepicker({
    dateFormat: "mm/dd/yy",
    changeMonth: true,
    changeYear: true
  });
  $("#button").click(function() {
    dayDiff($('#first').val(), $('#second').val());
  });
});

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<link rel="stylesheet" href="//code.jquery.com/ui/1.12.1/themes/base/jquery-ui.css">
<script src="//code.jquery.com/ui/1.12.1/jquery-ui.js"></script>

<input type="datetime" id="first" value="12/28/2016" />
<input type="datetime" id="second" value="12/28/2017" />
<input type="button" id="button" value="Calculate">

Ein Beitrag für das Datum vor dem 01.01.1970 und nach dem 19.01.2038

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

   function validateDate() {
        // get dates from input fields
        var startDate = $("#startDate").val();
        var endDate = $("#endDate").val();
        var sdate = startDate.split("-");
        var edate = endDate.split("-");
        var diffd = (edate[2] - sdate[2]) + 1;
        var leap = [ 0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 ];
        var nonleap = [ 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 ];
        if (sdate[0] > edate[0]) {
            alert("Please enter End Date Year greater than Start Date Year");
            document.getElementById("endDate").value = "";
            diffd = "";
        } else if (sdate[1] > edate[1]) {
            alert("Please enter End Date month greater than Start Date month");
            document.getElementById("endDate").value = "";
            diffd = "";
        } else if (sdate[2] > edate[2]) {
            alert("Please enter End Date greater than Start Date");
            document.getElementById("endDate").value = "";
            diffd = "";
        } else {
            if (sdate[0] / 4 == 0) {
                while (sdate[1] < edate[1]) {
                    diffd = diffd + leap[sdate[1]++];
                }
            } else {
                while (sdate[1] < edate[1]) {
                    diffd = diffd + nonleap[sdate[1]++];
                }
            }
            document.getElementById("numberOfDays").value = diffd;
        }
    }

Sie können UnderscoreJS zum Formatieren und Berechnen von Differenzen verwenden.

Demo https://jsfiddle.net/sumitridhal/8sv94msp/

 var startDate = moment("2016-08-29T23:35:01");
var endDate = moment("2016-08-30T23:35:01");  
  

console.log(startDate);
console.log(endDate);

var resultHours = endDate.diff(startDate, 'hours', true);

document.body.innerHTML = "";
document.body.appendChild(document.createTextNode(resultHours));

body { white-space: pre; font-family: monospace; }

<script src="https://cdnjs.cloudflare.com/ajax/libs/moment.js/2.5.1/moment.min.js"></script>