Come posso ottenere il numero di giorni tra due date in JavaScript?

Come posso ottenere il numero di giorni tra due date in JavaScript? Ad esempio, date due date nelle caselle di input:

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

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

Ecco un'implementazione rapida e sporca di datediff, come prova del concetto per risolvere il problema come presentato nella domanda. Si basa sul fatto che è possibile ottenere i millisecondi trascorsi tra due date sottraendoli, il che li costringe al loro valore numerico primitivo (millisecondi dall'inizio del 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"/>

Dovresti essere consapevole che le API di data "normali" (senza "UTC" nel nome) operano nel fuso orario locale del browser dell'utente, quindi in generale potresti incorrere in problemi se l'utente si trova in un fuso orario che non aspettarsi e il codice dovrà gestire le transizioni di ora legale. Dovresti leggere attentamente la documentazione per l'oggetto Date e i suoi metodi e, per qualsiasi cosa più complicata, considera fortemente l'uso di una libreria che offre API più sicure e potenti per la manipolazione della data.

• Numeri e date - Guida JavaScript MDN
• Date - Riferimento JavaScript MDN

_{Inoltre, a scopo illustrativo, lo snippet utilizza l' accesso denominato windowsull'oggetto per brevità, ma in produzione è necessario utilizzare API standardizzate come getElementById , o più probabilmente, un framework dell'interfaccia utente.}

Al momento della stesura di questo documento, solo una delle altre risposte gestisce correttamente le transizioni di ora legale (ora legale). Ecco i risultati su un sistema situato in California:

                                        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

Sebbene Math.roundrestituisca i risultati corretti, penso che sia un po 'goffo. Invece, tenendo conto esplicitamente delle modifiche all'offset UTC all'inizio o alla fine dell'ora legale, possiamo usare l'aritmetica esatta:

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

Spiegazione

I calcoli della data JavaScript sono complicati perché gli Dateoggetti memorizzano i tempi internamente in UTC, non l'ora locale. Ad esempio, 3/10/2013 12:00 AM Pacific Standard Time (UTC-08: 00) viene memorizzato come 3/10/2013 8:00 AM UTC e 3/11/2013 12:00 Pacific Daylight Time ( UTC-07: 00) è memorizzato come 11/03/2013 7:00 UTC. In questo giorno, l'ora locale da mezzanotte a mezzanotte è solo 23 ore in UTC!

Sebbene un giorno nell'ora locale possa avere più o meno di 24 ore, un giorno in UTC è sempre esattamente 24 ore. ¹ Il daysBetweenmetodo mostrato sopra sfrutta questo fatto chiamando prima treatAsUTCdi regolare entrambe le ore locali a mezzanotte UTC, prima di sottrarre e dividere.

^{1. JavaScript ignora i secondi bisestili.}

Il modo più semplice per ottenere la differenza tra due date:

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

Ottieni i giorni di differenza (o NaN se uno o entrambi non possono essere analizzati). La data di analisi ha dato il risultato in millisecondi e per ottenerlo per giorno devi dividerlo per 24 * 60 * 60 * 1000

Se lo vuoi diviso per giorni, ore, minuti, secondi e millisecondi:

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

Ecco la mia versione refactored della versione 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;
    }
}

Consiglio di utilizzare la libreria moment.js ( http://momentjs.com/docs/#/displaying/difference/ ). Gestisce correttamente l'ora legale e in generale è ottimo con cui lavorare.

Esempio:

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

Vorrei andare avanti e prendere questa piccola utility e in essa troverai funzioni per questo per te. Ecco un breve esempio:

        <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. Imposta la data di inizio
2. Imposta la data di fine
3. Calcola la differenza
4. Converti millisecondi in giorni

Aggiornamento: So che questo non fa parte delle tue domande, ma in generale non consiglierei di fare alcun calcolo o manipolazione della data in JavaScript vanilla e piuttosto utilizzare una libreria come date-fns o moment.js per questo a causa di molti casi limite.

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

I valori della data in JS sono valori datetime.

Pertanto, i calcoli diretti della data sono incoerenti:

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

per esempio dobbiamo convertire la 2a data:

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

il metodo potrebbe essere troncare i mulini in entrambe le date:

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

Meglio sbarazzarsi di DST, Math.ceil, Math.floor ecc. Utilizzando gli orari UTC:

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

Questo esempio fornisce 109 giorni di differenza. 24*60*60*1000è un giorno in millisecondi.

Per calcolare giorni tra 2 date indicate è possibile utilizzare il seguente codice. Le date che utilizzo qui sono il 01 gennaio 2016 e il 31 dicembre 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>

È possibile calcolare una differenza di giorni di prova completa tra due date che poggiano su TZ diverse utilizzando la seguente formula:

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

Ho trovato questa domanda quando volevo fare un calcolo su due date, ma la data ha valore di ore e minuti, ho modificato la risposta di @ michael-liu per soddisfare le mie esigenze e ha superato il mio test.

giorni diff 2012-12-31 23:00e 2013-01-01 01:00dovrebbe essere uguale a 1. (2 ore) giorni diff 2012-12-31 01:00e 2013-01-01 23:00dovrebbe essere uguale a 1. (46 ore)

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

esempio jsfiddle :)

Penso che le soluzioni non siano corrette al 100%. Userei ceil invece di floor , round funzionerà ma non è l'operazione giusta.

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

Che dire dell'utilizzo di formatDate dal widget DatePicker? Puoi usarlo per convertire le date nel formato timestamp (millisecondi dal 01/01/1970) e quindi fare una semplice sottrazione.

Questa potrebbe non essere la soluzione più elegante, ma sembra rispondere alla domanda con un codice relativamente semplice, credo. Non puoi usare qualcosa del genere:

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

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

return dayCount; 
}

Ciò presuppone che si stiano passando oggetti data come parametri.

Se hai due timestamp unix, puoi usare questa funzione (resa un po 'più dettagliata per motivi di chiarezza):

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

Esempio:

daysBetween(1096580303, 1308713220); // 2455

Fai attenzione quando usi i millisecondi .

Il Date.getTime () ritorna millisecondi e facendo operazione matematica con millisecondi richiede di includere

• Ora legale (DST)
• verifica se entrambe le date hanno lo stesso orario (ore, minuti, secondi, millisecondi)
• assicurati quale comportamento dei giorni diff è richiesto: 19 settembre 2016 - 29 settembre 2016 = 1 o 2 giorni di differenza?

L'esempio del commento sopra è la migliore soluzione che ho trovato finora https://stackoverflow.com/a/11252167/2091095 . Ma usa +1 per il suo risultato se vuoi che conti tutti i giorni coinvolti.

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;

Ho avuto lo stesso problema in Angular. Faccio la copia perché altrimenti sovrascriverà il primo appuntamento. Entrambe le date devono avere il tempo 00:00:00 (ovviamente)

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

Ho usato il codice seguente per sperimentare la funzionalità della data di pubblicazione per un post di notizie. Calcolo il minuto o l'ora o il giorno o l'anno in base alla data di pubblicazione e alla data corrente.

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

se vuoi avere un DateArray con date prova questo:

<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

Il modo semplice per calcolare i giorni tra due date è rimuovere entrambe le componenti del tempo, ovvero impostare ore, minuti, secondi e millisecondi su 0 e quindi sottrarre il loro tempo e immergerlo con millisecondi di un giorno.

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

Semplice facile e sofisticato. Questa funzione verrà chiamata ogni 1 secondo per aggiornare l'ora.

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

Una soluzione migliore di

Ignorando la parte temporale

restituirà 0 se entrambe le date sono uguali.

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

Un contributo, per la data precedente al 1970-01-01 e dopo il 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);
  })();
}

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

È possibile utilizzare UnderscoreJS per la formattazione e il calcolo della differenza.

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>