Comment obtenir le nombre de jours entre deux dates en JavaScript?

Comment obtenir le nombre de jours entre deux dates en JavaScript? Par exemple, étant donné deux dates dans les zones de saisie:

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

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

Voici une implémentation rapide et sale de datediff, comme preuve de concept pour résoudre le problème tel que présenté dans la question. Il repose sur le fait que vous pouvez obtenir les millisecondes écoulées entre deux dates en les soustrayant, ce qui les contraint à leur valeur numérique primitive (millisecondes depuis le début de 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"/>

Vous devez savoir que les API de date "normales" (sans "UTC" dans le nom) fonctionnent dans le fuseau horaire local du navigateur de l'utilisateur, donc en général, vous pourriez rencontrer des problèmes si votre utilisateur se trouve dans un fuseau horaire que vous n'avez pas attendez-vous, et votre code devra gérer les transitions d'heure d'été. Vous devez lire attentivement la documentation de l'objet Date et de ses méthodes, et pour tout ce qui est plus compliqué, pensez sérieusement à utiliser une bibliothèque qui propose des API plus sûres et plus puissantes pour la manipulation des dates.

• Numéros et dates - MDN JavaScript Guide
• Date - Référence JavaScript MDN

_{De plus, à des fins d'illustration, l'extrait de code utilise l' accès nommé sur l' windowobjet par souci de concision, mais en production, vous devez utiliser des API standardisées comme getElementById , ou plus probablement, un cadre d'interface utilisateur.}

Au moment d'écrire ces lignes, une seule des autres réponses gère correctement les transitions DST (heure d'été). Voici les résultats sur un système situé en Californie:

                                        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

Bien que Math.roundrenvoie les résultats corrects, je pense que c'est un peu maladroit. Au lieu de cela, en prenant explicitement en compte les modifications du décalage UTC au début ou à la fin de l'heure d'été, nous pouvons utiliser l'arithmétique exacte:

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

Explication

Les calculs de date JavaScript sont délicats car les Dateobjets stockent les heures en interne en UTC, pas l'heure locale. Par exemple, 3/10/2013 12:00 AM heure normale du Pacifique (UTC-08: 00) est stockée sous la forme 3/10/2013 8:00 AM UTC et 3/11/2013 12:00 AM Pacific Daylight Time ( UTC-07: 00) est stocké sous la forme 3/11/2013 7:00 AM UTC. Ce jour-là, de minuit à minuit, l'heure locale n'est que de 23 heures en UTC!

Bien qu'une journée dans l'heure locale puisse avoir plus ou moins de 24 heures, une journée en UTC est toujours exactement 24 heures. ¹ La daysBetweenméthode illustrée ci-dessus tire parti de ce fait en appelant d'abord treatAsUTCpour ajuster les deux heures locales à minuit UTC, avant de soustraire et de diviser.

^{1. JavaScript ignore les secondes intercalaires.}

Le moyen le plus simple pour faire la différence entre deux dates:

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

Vous obtenez les jours de différence (ou NaN si l'un ou les deux n'ont pas pu être analysés). La date d'analyse a donné le résultat en millisecondes et pour l'obtenir le jour, vous devez le diviser par 24 * 60 * 60 * 1000

Si vous le souhaitez divisé par jours, heures, minutes, secondes et millisecondes:

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

Voici ma version refactorisée de la version 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;
    }
}

Je recommande d'utiliser la bibliothèque moment.js ( http://momentjs.com/docs/#/displaying/difference/ ). Il gère correctement l'heure d'été et est généralement génial pour travailler avec.

Exemple:

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

Je voudrais aller de l'avant et saisir ce petit utilitaire et vous y trouverez des fonctions pour vous. Voici un petit exemple:

        <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. Définir la date de début
2. Fixer la date de fin
3. Calculer la différence
4. Conversion millisecondes en jours

Mise à jour: je sais que cela ne fait pas partie de vos questions, mais en général, je ne recommanderais pas de faire de calcul ou de manipulation de date en JavaScript vanilla et d'utiliser plutôt une bibliothèque comme date-fns ou moment.js pour cela en raison de nombreux cas extrêmes .

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

Les valeurs de date dans JS sont des valeurs datetime.

Ainsi, les calculs de date directs sont incohérents:

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

par exemple, nous devons convertir la 2e date:

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

la méthode pourrait être tronquer les moulins aux deux dates:

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

Mieux vaut se débarrasser de l'heure d'été, Math.ceil, Math.floor etc. en utilisant les heures 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));

Cet exemple donne une différence de 109 jours. 24*60*60*1000est un jour en millisecondes.

Pour calculer les jours entre 2 dates données, vous pouvez utiliser le code suivant. Les dates que j'utilise ici sont le 1er janvier 2016 et le 31 décembre 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>

Il est possible de calculer une différence de jours de preuve complète entre deux dates reposant sur différentes ZT en utilisant la formule suivante:

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

J'ai trouvé cette question lorsque je veux faire un calcul à deux dates, mais la date a une valeur d'heures et de minutes, j'ai modifié la réponse de @ michael-liu pour qu'elle corresponde à mes besoins et elle a réussi mon test.

jours diff 2012-12-31 23:00et 2013-01-01 01:00devrait être égal à 1. (2 heures) jours diff 2012-12-31 01:00et 2013-01-01 23:00devrait être égal à 1. (46 heures)

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

exemple jsfiddle :)

Je pense que les solutions ne sont pas correctes à 100% J'utiliserais le plafond au lieu du sol , le rond fonctionnera mais ce n'est pas la bonne opération.

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

Qu'en est- il en utilisant formatDate de widget de DatePicker? Vous pouvez l'utiliser pour convertir les dates au format d'horodatage (millisecondes depuis le 01/01/1970) puis effectuer une simple soustraction.

Ce n'est peut-être pas la solution la plus élégante, mais cela semble répondre à la question avec un peu de code relativement simple, je pense. Ne pouvez-vous pas utiliser quelque chose comme ça:

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

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

return dayCount; 
}

Cela suppose que vous transmettez des objets de date en tant que paramètres.

Si vous avez deux horodatages Unix, vous pouvez utiliser cette fonction (rendue un peu plus verbeuse pour plus de clarté):

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

Exemple:

daysBetween(1096580303, 1308713220); // 2455

Soyez prudent lorsque vous utilisez des millisecondes .

La date.getTime () renvoie des millisecondes et effectuer une opération mathématique avec des millisecondes nécessite d'inclure

• Heure d'été (DST)
• vérifier si les deux dates ont la même heure (heures, minutes, secondes, millisecondes)
• assurez-vous quel comportement de jours diff est requis: 19 septembre 2016 - 29 septembre 2016 = 1 ou 2 jours de différence?

L'exemple du commentaire ci-dessus est la meilleure solution que j'ai trouvée jusqu'à présent https://stackoverflow.com/a/11252167/2091095 . Mais utilisez +1 pour son résultat si vous souhaitez que le compte tous les jours impliqués.

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;

J'ai eu le même problème dans Angular. Je fais la copie car sinon il écrasera la première date. Les deux dates doivent avoir une heure 00:00:00 (évidemment)

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

J'ai utilisé le code ci-dessous pour expérimenter la fonctionnalité de date de publication pour un article de presse.Je calcule la minute ou l'heure ou le jour ou l'année en fonction de la date de publication et de la date actuelle.

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

si vous voulez avoir un DateArray avec des dates, essayez ceci:

<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

Le moyen simple de calculer les jours entre deux dates est de supprimer les deux composantes de leur temps, c'est-à-dire de régler les heures, les minutes, les secondes et les millisecondes à 0, puis de soustraire leur temps et de le plonger avec des millisecondes d'une journée.

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

Simple, simple et sophistiqué. Cette fonction sera appelée toutes les 1 s pour mettre à jour l'heure.

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

Une meilleure solution par

Ignorer la partie temps

il renverra 0 si les deux dates sont identiques.

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

Une contribution, pour une date antérieure au 01/01/1970 et postérieure au 20/01/01

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

Vous pouvez utiliser UnderscoreJS pour formater et calculer la différence.

Démo 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>