Comment puis-je obtenir le nombre de jours entre deux dates en JavaScript?
Comment puis-je obtenir le nombre de jours entre deux dates en JavaScript? Par exemple, à partir de 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 quick and dirty de datediff, comme preuve de concept pour résoudre le problème 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 dans 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. Par conséquent, vous pouvez généralement rencontrer des problèmes si votre utilisateur se trouve dans un fuseau horaire que vous n'utilisez pas. attendez-vous, et votre code devra faire face aux transitions d’heure d’été. Vous devez lire attentivement la documentation de l'objet Date et de ses méthodes, et pour les tâches plus complexes, envisagez vivement d'utiliser une bibliothèque offrant des API plus sûres et plus puissantes pour la manipulation des dates.
De plus, à des fins d'illustration, l'extrait utilise nommé l'accès sur l'objet window par souci de brièveté, mais en production, vous devez utiliser des API normalisées telles que getElementById , ou plus probablement, certaines structures 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.round renvoie les résultats corrects, je pense que c'est un peu maladroit. Au lieu de cela, en prenant en compte explicitement les modifications apportées au 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 objets Date enregistrent les heures en interne au format UTC, et non l'heure locale. Par exemple, l'heure standard du Pacifique du 3/10/2013 à 00h00 (UTC-08: 00) est enregistrée sous le 3/10/2013 8:00 UTC et le 3/11/2013 à l'heure avancée du Pacifique ( UTC-07: 00) est stocké sous le 3/11/2013 7:00 UTC. En ce jour, l'heure locale de minuit à minuit n'est que de 23 heures en UTC!
Même si une journée en heure locale peut durer plus ou moins de 24 heures, une journée en UTC correspond toujours exactement à 24 heures.1 La méthode daysBetween présentée ci-dessus tire parti de ce fait en appelant d'abord treatAsUTC pour ajuster les deux heures locales à minuit UTC, avant de soustraire et de diviser.
1. JavaScript ignore les secondes intercalaires.
Le moyen le plus simple d’obtenir 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 donne le résultat en millisecondes et pour l'obtenir par 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 de 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 il est généralement agréable de travailler avec lui.
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 attraper ce petit utilitaire et vous y trouverez des fonctions pour cela. Voici un court 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>
Utiliser 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.
Donc, les calculs de date directe sont incohérents:
(2013-11-05 00:00:00) - (2013-11-04 10:10:10) < 1 day
par exemple, nous devons convertir de 2nd 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);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)
- Définir la date de début
- Fixer la date de fin
- Calculer la différence
- Convertir des millisecondes en jours
Pour calculer les jours entre deux dates données, vous pouvez utiliser le code suivant.
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>Mieux vaut se débarrasser de DST, Math.ceil, Math.floor etc.
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 la différence 109 jours. 24*60*60*1000 est un jour en millisecondes.
J'ai trouvé cette question quand je veux faire un calcul sur deux dates, mais les dates ont une valeur en heures et en minutes, j'ai modifié la réponse de @ michael-liu pour qu'elle corresponde à mes exigences, et le test a réussi.
diff jours 2012-12-31 23:00 et 2013-01-01 01:00 devraient être égaux à 1. (2 heures) diff jours 2012-12-31 01:00 et 2013-01-01 23:00 devraient être égaux à 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);
}
Pourquoi ne pas utiliser formatDate à partir du widget DatePicker? Vous pouvez l'utiliser pour convertir les dates au format timestamp (millisecondes depuis le 01/01/1970), puis effectuer une simple soustraction.
Je pense que les solutions ne sont pas correctes à 100%. J'utiliserais ceil au lieu de floor , round 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)
};
}
Il est possible de calculer une différence de jours de preuve complète entre deux dates reposant sur différentes zones de stockage 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);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()));var start= $("#firstDate").datepicker("getDate");
var end= $("#SecondDate").datepicker("getDate");
var days = (end- start) / (1000 * 60 * 60 * 24);
alert(Math.round(days));
jsfiddle exemple :)
Soyez prudent lorsque vous utilisez millisecondes.
Date.getTime () renvoie des millisecondes et effectuer l'opération math 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 que le comportement des jours diff est requis: 19 septembre 2016 - 29 septembre 2016 = différence de 1 ou 2 jours?
L'exemple tiré 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 obtenir son résultat si vous voulez que tous les jours soient compté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;
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 daysJ'ai utilisé le code ci-dessous pour expérimenter la fonctionnalité de date de publication pour un article de journal.
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 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>
Le moyen le plus simple de calculer des jours entre deux dates consiste à supprimer leur composante temps, c’est-à-dire régler les heures, les minutes, les secondes et les millisecondes sur 0, puis les soustraire et les plonger avec une valeur correspondant à 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);
Ce n'est peut-être pas la solution la plus élégante, mais elle semble répondre à la question avec un morceau de code relativement simple, je pense. Ne pouvez-vous pas utiliser quelque chose comme ceci:
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.
J'ai eu le même problème dans Angular. Je fais la copie parce que sinon il écrasera la première date. Les deux dates doivent avoir l'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;
};
Si vous avez deux horodatages Unix, vous pouvez utiliser cette fonction (rendue un peu plus détaillée 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
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;
}
Une meilleure solution par
Ignorer une partie du temps
il retournera 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 1970-01-01 et après 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);
})();
}
Bookmarklet version d'autres réponses, vous invitant pour les deux dates:
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)
)
));
})();
Simple facile et sophistiqué. Cette fonction sera appelée toutes les secondes 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);
J'ai eu le même problème, mais c'est mieux si vous l'avez fait avec SQL Query:
DateDiff(DAY, StartValue,GETDATE()) AS CountDays
la requête générera automatiquement une colonne CountDays
Je me suis inspiré d'autres réponses pour faire en sorte que les intrants disposent d'un assainissement automatique. J'espère que cela fonctionne bien comme une amélioration par rapport aux autres réponses.
//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>Cette réponse, basée sur une autre (lien à la fin), concerne la différence entre deux dates.
Vous pouvez voir comment cela fonctionne parce que c’est simple, cela implique également de scinder la différence en
unités de temps (une fonction que j'ai créée) et conversion en UTC pour résoudre les problèmes de fuseau horaire.
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)] );} ));Comment fonctionne mon code ci-dessus
Une différence date/heure, exprimée en millisecondes, peut être calculée à l'aide de l'objet Date :
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.
Ensuite, pour calculer le nombre de secondes dans cette différence, divisez-le par 1000 pour le convertir.
millisecondes en secondes, puis changez le résultat en entier (nombre entier) à supprimer
les millisecondes (fraction de la décimale): var seconds = parseInt(diff/1000).
En outre, je pourrais obtenir des unités de temps plus longues en utilisant le même processus, par exemple:
- (entier) minutes, en divisant secondes par 60 et en transformant le résultat en entier,
- heures, en divisant minutes par 60 et en transformant le résultat en entier.
J'ai créé une fonction pour faire ce processus de scission de la différence en
unités de temps entières, nommées split_to_whole_units, avec cette démo:
console.log(split_to_whole_units(72000, [1000, 60]));
// -> [1,12,0] # 1 (whole) minute, 12 seconds, 0 milliseconds.
Cette réponse est basée sur cet autre .
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 le formatage et le calcul de la différence.
Démohttps://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>Je n'ai que deux horodatages en millisecondes, je dois donc faire quelques pas supplémentaires avec moment.js pour obtenir les jours entre les deux.
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