wake-up-neo.com

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

Wie erhalte ich die Anzahl der Tage zwischen zwei Datumsangaben in JavaScript? Geben Sie beispielsweise zwei Datumsangaben 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>
329
Michael Haren

Hier ist eine quick and dirty -Implementierung von datediff als Beweis für das Konzept, um das in der Frage dargestellte Problem zu lösen. Sie beruht auf der Tatsache, dass Sie die verstrichenen Millisekunden zwischen zwei Datumsangaben abrufen können, indem Sie sie abziehen, wodurch sie in ihren primitiven Zahlenwert (Millisekunden seit Anfang 1970) umgewandelt 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 dessen bewusst sein, dass die "normalen" Date-APIs (ohne "UTC" im Namen) in der lokalen Zeitzone des Browsers des Benutzers ausgeführt werden. In der Regel können Sie also auf Probleme stoßen, wenn sich Ihr Benutzer in einer Zeitzone befindet, die Sie nicht verwenden erwarten, und Ihr Code muss sich mit den Übergängen der Sommerzeit beschäftigen. Sie sollten die Dokumentation des Date-Objekts und seiner Methoden sorgfältig durchlesen. Bei komplizierteren Funktionen sollten Sie unbedingt eine Bibliothek in Betracht ziehen, die sicherere und leistungsfähigere APIs für die Datumsmanipulation bietet.

Zum Zwecke der Veranschaulichung verwendet das Snippet benannten Zugriff auf das window-Objekt der Kürze halber, aber in der Produktion sollten Sie standardisierte APIs wie getElementById verwenden, oder eher ein UI-Framework.

353
Miles

Zum jetzigen Zeitpunkt kann nur eine der anderen Antworten DST-Übergänge (Sommerzeit) korrekt verarbeiten. Hier sind die Ergebnisse für ein System 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.round die korrekten Ergebnisse liefert, denke ich, dass es etwas klobig ist. Durch explizite Berücksichtigung von Änderungen des UTC-Offsets beim Beginn oder Ende der Sommerzeit können wir die exakte Arithmetik verwenden:

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 Date-Objekte die Zeiten intern in UTC und nicht in der Ortszeit speichern. Beispiel: Die 10/10/2013 12:00 AM Pacific Standard Time (UTC-08: 00) wird als 3/10/2013 8:00 AM UTC und 11.03.2013 12:00 AM Pacific Daylight Time ( UTC-07: 00) wird gespeichert als 11.03.2013 07:00 UTC. An diesem Tag beträgt die Ortszeit Mitternacht bis Mitternacht in UTC nur 23 Stunden!

Obwohl ein Tag in der Ortszeit mehr oder weniger als 24 Stunden umfassen kann, ist ein Tag in UTC immer genau 24 Stunden.1 Die oben gezeigte daysBetween-Methode nutzt diese Tatsache, indem sie zuerst treatAsUTC aufruft, um beide Ortszeiten auf Mitternacht-UTC einzustellen, bevor sie subtrahiert und dividiert wird.

1. JavaScript ignoriert Schaltsekunden.

187
Michael Liu

Der einfachste Weg, um den Unterschied zwischen zwei Terminen 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 Datum der Analyse ergab das Ergebnis in Millisekunden. Um es am Tag zu erhalten, muss es durch 24 * 60 * 60 * 1000 geteilt werden

Wenn Sie es nach Tagen, Stunden, Minuten, Sekunden und Millisekunden teilen möchten:

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 refactored Version von 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;
    }
}
106
some

Ich empfehle die Verwendung der moment.js-Bibliothek ( http://momentjs.com/docs/#/displaying/difference/ ). Es verarbeitet die Sommerzeit korrekt und ist im Allgemeinen sehr gut damit zu arbeiten.

Beispiel:

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

Ich würde weitermachen und dieses kleine Dienstprogramm ergreifen und darin werden Sie Funktionen dazu finden. 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>
40
fuentesjr

Moment.js verwenden 

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>

12
Michael K

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 zweite Datum konvertieren:

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

die Methode könnte die Mühlen in beiden Terminen abschneiden: 

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
Norris
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. Millisekunden in Tage umrechnen
9
marcobiedermann

Um Tage zwischen zwei angegebenen Daten zu berechnen, können Sie den folgenden Code verwenden. Ich verwende hier den 1. Januar 2016 und den 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>

9
NooNa MarJa

Besser ist es, 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 ergibt einen Unterschied von 109 Tagen. 24*60*60*1000 ist ein Tag in Millisekunden.

8
Timo Kähkönen

Ich habe diese Frage gefunden, wenn ich an zwei Tagen etwas berechnen möchte, aber das Datum hat Stunden- und Minutenwert, ich habe die Antwort von @ michael-liu an meine Anforderung angepasst und meine Prüfung bestanden.

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

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);
}
6
guilin 桂林

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

6
kgiannakakis

Ich denke, die Lösungen sind nicht korrekt. 100% würde ich verwenden - ceil anstelle von floor .

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)
    };
}
6
Tolo Palmer

Es ist möglich, eine vollständige Differenz zwischen zwei Tagen zwischen zwei TZs zu berechnen, indem die folgende Formel verwendet wird:

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

6
riv

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

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

jsfiddle Beispiel :)

5
Aravindh Gopi

Seien Sie vorsichtig, wenn Sie Millisekunden verwenden.

Die date.getTime () gibt Millisekunden zurück, und für die math-Operation mit Millisekunden müssen

  • Sommerzeit (DST)
  • Überprüfen, ob beide Datumsangaben die gleiche Zeit haben (Stunden, Minuten, Sekunden, Millisekunden)
  • vergewissern Sie sich, welches Verhalten von Tagen diff erforderlich 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 alle betroffenen Tage gezählt werden sollen.

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;
4
Dalibor Matura

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

4
Abdennour TOUMI

Ich habe den folgenden Code verwendet, um die Funktionalität des Buchungsdatums für eine Nachrichtenpost zu testen. Ich berechne die Minute, Stunde, den Tag oder das Jahr anhand des Buchungsdatums und des aktuellen Datums. 

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

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

3
Ricardo Fercher

Die einfache Möglichkeit, Tage zwischen zwei Datumsangaben zu berechnen, besteht darin, beide Zeitkomponenten zu entfernen, d. H. Die Stunden, Minuten, Sekunden und Millisekunden auf 0 zu setzen und dann ihre Zeit abzuziehen und mit einem Millisekundenwert 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);
3
Sriman Pathy

Dies ist vielleicht nicht die eleganteste Lösung, scheint aber die Frage mit einem relativ einfachen 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.

3
Popmatic

Ich hatte das gleiche Problem in Angular. Ich mache die Kopie, weil er sonst das erste Datum überschreiben wird. Beide Datumsangaben müssen um 00:00:00 Uhr liegen (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;
};
3
user3806549

Wenn Sie zwei Unix-Zeitstempel haben, können Sie diese Funktion verwenden (aus Gründen der Klarheit 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
3
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;
}
2
zloctb

Eine bessere Lösung von 

Zeitteil ignorieren

wenn beide Datumsangaben identisch sind, wird 0 zurückgegeben.

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

1
Sumit Joshi

Ein Beitrag für das Datum vor 1970-01-01 und nach 2038-01-19

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

Bookmarklet-Version anderer Antworten, die Sie zu beiden Terminen auffordert:

javascript:(function() {
    var d = new Date(Prompt("First Date or leave blank for today?") || Date.now());
    Prompt("Days Between", Math.round(
        Math.abs(
            (d.getTime() - new Date(Prompt("Date 2")).getTime())
                /(24*60*60*1000)
             )
        ));
})();
0
drzaus

Einfach, einfach und anspruchsvoll. Diese Funktion wird alle 1 Sek. Zur Aktualisierung aufgerufen.

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);
0
Varun Raj

Ich hatte das gleiche Problem, aber es ist besser, wenn Sie es mit SQL Query gemacht haben:

DateDiff(DAY, StartValue,GETDATE()) AS CountDays

die Abfrage generiert automatisch eine Spalte CountDays

Ich habe mich von anderen Antworten inspirieren lassen und die Eingänge automatisch saniert. Ich hoffe, dass dies als Verbesserung gegenüber anderen Antworten gut funktioniert.

//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 > 5 && str.length < 10) {
      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>

0
lewdev

Diese Antwort, basierend auf einer anderen (link am Ende), bezieht sich auf die Differenz zwischen zwei Datumsangaben.
Sie können sehen, wie es funktioniert, weil es einfach ist, es beinhaltet auch die Aufteilung der Differenz in
Zeiteinheiten (eine Funktion, die ich erstellt habe) und Konvertierung in UTC, um Zeitzonenprobleme zu stoppen.

function date_units_diff(a, b, unit_amounts) {
    var split_to_whole_units = function (milliseconds, unit_amounts) {
        // unit_amounts = list/array of amounts of milliseconds in a
        // second, seconds in a minute, etc., for example "[1000, 60]".
        time_data = [milliseconds];
        for (i = 0; i < unit_amounts.length; i++) {
            time_data.Push(parseInt(time_data[i] / unit_amounts[i]));
            time_data[i] = time_data[i] % unit_amounts[i];
        }; return time_data.reverse();
    }; if (unit_amounts == undefined) {
        unit_amounts = [1000, 60, 60, 24];
    };
    var utc_a = new Date(a.toUTCString());
    var utc_b = new Date(b.toUTCString());
    var diff = (utc_b - utc_a);
    return split_to_whole_units(diff, unit_amounts);
}

// Example of use:
var d = date_units_diff(new Date(2010, 0, 1, 0, 0, 0, 0), new Date()).slice(0,-2);
document.write("In difference: 0 days, 1 hours, 2 minutes.".replace(
   /0|1|2/g, function (x) {return String( d[Number(x)] );} ));

Wie mein Code oben funktioniert

Eine Datums-/Zeitdifferenz in Millisekunden kann mit dem Objekt Date berechnet werden:

var a = new Date(); // Current date now.
var b = new Date(2010, 0, 1, 0, 0, 0, 0); // Start of 2010.

var utc_a = new Date(a.toUTCString());
var utc_b = new Date(b.toUTCString());
var diff = (utc_b - utc_a); // The difference as milliseconds.

Um die Anzahl der Sekunden in dieser Differenz zu ermitteln, dividieren Sie sie zum Konvertieren in 1000
Millisekunden bis Sekunden. Ändern Sie das Ergebnis in eine Ganzzahl (ganze Zahl), die Sie entfernen möchten
die Millisekunden (Bruchteil dieser Dezimalzahl): var seconds = parseInt(diff/1000).
Außerdem könnte ich längere Zeiteinheiten mit demselben Verfahren verwenden, zum Beispiel:
- (gesamt) Minuten, Sekunden durch 60 dividieren und das Ergebnis in eine Ganzzahl ändern,
- Stunden, Minuten durch 60 teilen und das Ergebnis in eine Ganzzahl ändern.

Ich habe eine Funktion erstellt, um diesen Unterschied aufzuteilen
ganze Zeiteinheiten mit dem Namen split_to_whole_units, mit dieser Demo:

console.log(split_to_whole_units(72000, [1000, 60]));
// -> [1,12,0] # 1 (whole) minute, 12 seconds, 0 milliseconds.

Diese Antwort basiert auf diesem anderen .

0
Edward
   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;
        }
    }
0
Parmanand Shete

Sie können UnderscoreJS zur Formatierung und Differenzberechnung verwenden.

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

0
Sumit Ridhal

Ich habe nur zwei Zeitstempel in Millisekunden, also muss ich mit moment.js ein paar zusätzliche Schritte machen, um die Tage dazwischen zu bekommen.

const getDaysDiff = (fromTimestamp, toTimestamp) => {
    // set timezone offset with utcOffset if needed
    let fromDate = moment(fromTimestamp).utcOffset(8);
    let toDate = moment(toTimestamp).utcOffset(8);
    // get the start moment of the day
    fromDate.set({'hour':0, 'minute': 0, 'second': 0, 'millisecond': 0});
    toDate.set({'hour':0, 'minute': 0, 'second': 0, 'millisecond': 0});
    let diffDays = toDate.diff(fromDate, 'days');

    return diffDays;
}

getDaysDiff(1528889400000, 1528944180000)// 1 
0
wj2061