# Javascript return number of days,hours,minutes,seconds between two dates

Does anyone can link me to some tutorial where I can find out how to return days , hours , minutes, seconds in javascript between 2 unix datetimes?

I have:

``````var date_now = unixtimestamp;
var date_future = unixtimestamp;
``````

I would like to return (live) how many days,hours,minutes,seconds left from the date_now to the date_future. Just figure out the difference in seconds (don't forget JS timestamps are actually measured in milliseconds) and decompose that value:

``````// get total seconds between the times
var delta = Math.abs(date_future - date_now) / 1000;

// calculate (and subtract) whole days
var days = Math.floor(delta / 86400);
delta -= days * 86400;

// calculate (and subtract) whole hours
var hours = Math.floor(delta / 3600) % 24;
delta -= hours * 3600;

// calculate (and subtract) whole minutes
var minutes = Math.floor(delta / 60) % 60;
delta -= minutes * 60;

// what's left is seconds
var seconds = delta % 60;  // in theory the modulus is not required
``````

EDIT code adjusted because I just realised that the original code returned the total number of hours, etc, not the number of hours left after counting whole days. Here's in javascript: (For example, the future date is New Year's Day)

``````var dateFuture = new Date(new Date().getFullYear() +1, 0, 1);
var dateNow = new Date();

var seconds = Math.floor((dateFuture - (dateNow))/1000);
var minutes = Math.floor(seconds/60);
var hours = Math.floor(minutes/60);
var days = Math.floor(hours/24);

hours = hours-(days*24);
minutes = minutes-(days*24*60)-(hours*60);
seconds = seconds-(days*24*60*60)-(hours*60*60)-(minutes*60);
`````` Please note that calculating only based on differences will not cover all cases: leap years and switching of "daylight savings time".

Javascript has poor built-in library for working with dates. I suggest you use a third party javascript library, e.g. MomentJS; you can see here the function you were looking for. The best library that I know of for duration breakdown is countdown.js. It handles all the hard cases such as leap years and daylight savings as csg mentioned, and even allows you to specify fuzzy concepts such as months and weeks. Here's the code for your case:

``````//assuming these are in *seconds* (in case of MS don't multiply by 1000 below)
var date_now = 1218374;
var date_future = 29384744;

diff = countdown(date_now * 1000, date_future * 1000,
countdown.DAYS | countdown.HOURS | countdown.MINUTES | countdown.SECONDS);
alert("days: " + diff.days + " hours: " + diff.hours +
" minutes: " + diff.minutes + " seconds: " + diff.seconds);

//or even better
``````

Here's a JSFiddle, but it would probably only work in FireFox or in Chrome with web security disabled, since countdown.js is hosted with a text/plain MIME type (you're supposed to serve the file, not link to countdownjs.org). my solution is not as clear as that, but I put it as another example

``````console.log(duration('2019-07-17T18:35:25.235Z', '2019-07-20T00:37:28.839Z'));

function duration(t0, t1){
let d = (new Date(t1)) - (new Date(t0));
let days         = Math.floor(d/1000/60/60/24 - weekdays*7);
let hours        = Math.floor(d/1000/60/60    - weekdays*7*24            - days*24);
let minutes      = Math.floor(d/1000/60       - weekdays*7*24*60         - days*24*60         - hours*60);
let seconds      = Math.floor(d/1000          - weekdays*7*24*60*60      - days*24*60*60      - hours*60*60      - minutes*60);
let milliseconds = Math.floor(d               - weekdays*7*24*60*60*1000 - days*24*60*60*1000 - hours*60*60*1000 - minutes*60*1000 - seconds*1000);
let t = {};
['weekdays', 'days', 'hours', 'minutes', 'seconds', 'milliseconds'].forEach(q=>{ if (eval(q)>0) { t[q] = eval(q); } });
return t;
}`````` Here is a code example. I used simple calculations instead of using precalculations like 1 day is 86400 seconds. So you can follow the logic with ease.

``````// Calculate time between two dates:
var date1 = new Date('1110-01-01 11:10');
var date2 = new Date();

console.log('difference in ms', date1 - date2);

// Use Math.abs() so the order of the dates can be ignored and you won't
// end up with negative numbers when date1 is before date2.
console.log('difference in ms abs', Math.abs(date1 - date2));
console.log('difference in seconds', Math.abs(date1 - date2) / 1000);

var diffInSeconds = Math.abs(date1 - date2) / 1000;
var days = Math.floor(diffInSeconds / 60 / 60 / 24);
var hours = Math.floor(diffInSeconds / 60 / 60 % 24);
var minutes = Math.floor(diffInSeconds / 60 % 60);
var seconds = Math.floor(diffInSeconds % 60);
var milliseconds = Math.round((diffInSeconds - Math.floor(diffInSeconds)) * 1000);

console.log('days', days);
console.log('hours', ('0' + hours).slice(-2));
console.log('minutes', ('0' + minutes).slice(-2));
console.log('seconds', ('0' + seconds).slice(-2));
console.log('milliseconds', ('00' + milliseconds).slice(-3));
`````` ``````function update(datetime = "2017-01-01 05:11:58") {
var theevent = new Date(datetime);
now = new Date();
var sec_num = (theevent - now) / 1000;
var days    = Math.floor(sec_num / (3600 * 24));
var hours   = Math.floor((sec_num - (days * (3600 * 24)))/3600);
var minutes = Math.floor((sec_num - (days * (3600 * 24)) - (hours * 3600)) / 60);
var seconds = Math.floor(sec_num - (days * (3600 * 24)) - (hours * 3600) - (minutes * 60));

if (hours   < 10) {hours   = "0"+hours;}
if (minutes < 10) {minutes = "0"+minutes;}
if (seconds < 10) {seconds = "0"+seconds;}

return  days+':'+ hours+':'+minutes+':'+seconds;
}
`````` Short and flexible with support for negative values, although by using two comma expressions :)

``````function timeUnitsBetween(startDate, endDate) {
let delta = Math.abs(endDate - startDate) / 1000;
const isNegative = startDate > endDate ? -1 : 1;
return [
['days', 24 * 60 * 60],
['hours', 60 * 60],
['minutes', 60],
['seconds', 1]
].reduce((acc, [key, value]) => (acc[key] = Math.floor(delta / value) * isNegative, delta -= acc[key] * isNegative * value, acc), {});
}
``````

Example:

``````timeUnitsBetween(new Date("2019-02-11T02:12:03+00:00"), new Date("2019-02-11T01:00:00+00:00"));
// { days: -0, hours: -1, minutes: -12, seconds: -3 }
``````

Inspired by RienNeVaPlu?s solution. here is an code to find difference between two dates in Days,Hours,Minutes,Seconds (assuming the future date is new year date).

``````var one_day = 24*60*60*1000;              // total milliseconds in one day

var today = new Date();
var new_year = new Date("01/01/2017");    // future date

var today_time = today.getTime();         // time in miliiseconds
var new_year_time = new_year.getTime();

var time_diff = Math.abs(new_year_time - today_time);  //time diff in ms
var days = Math.floor(time_diff / one_day);            // no of days

var remaining_time = time_diff - (days*one_day);      // remaining ms

var hours = Math.floor(remaining_time/(60*60*1000));
remaining_time = remaining_time - (hours*60*60*1000);

var minutes = Math.floor(remaining_time/(60*1000));
remaining_time = remaining_time - (minutes * 60 * 1000);

var seconds = Math.ceil(remaining_time / 1000);
`````` ``````let delta = Math.floor(Math.abs(start.getTime() - end.getTime()) / 1000);
let hours = Math.floor(delta / 3600);
delta -= hours * 3600;
let minutes = Math.floor(delta / 60);
delta -= minutes * 60;
let seconds = delta;
if (hours.toString().length === 1) {
hours = `0\${hours}`;
}
if (minutes.toString().length === 1) {
minutes = `0\${minutes}`;
}
if (seconds.toString().length === 1) {
seconds = `0\${seconds}`;
}
const recordingTime = `\${hours}:\${minutes}:\${seconds}`;
`````` MomentJS has a function to do that:

``````const start = moment(j.timings.start);
const end = moment(j.timings.end);
const elapsedMinutes = end.diff(start, "minutes");
`````` Here's my take:

``````timeSince(123456) => "1 day, 10 hours, 17 minutes, 36 seconds"
``````

And the code:

``````function timeSince(date, longText) {
let seconds = null;

if (date instanceof Date) {
seconds = Math.floor((new Date() - date) / 1000);
if (seconds < 0) {
} else {
}
seconds = Math.abs(seconds);
} else {
seconds = date;
}

const intervals = [
[31536000, "year"  ],
[ 2592000, "month" ],
[   86400, "day"   ],
[    3600, "hour"  ],
[      60, "minute"],
[       1, "second"],
];

let interval = seconds;
let intervalStrings = [];
for (let i = 0; i < intervals.length; i++) {
let divResult = Math.floor(interval / intervals[i]);
if (divResult > 0) {
intervalStrings.push(divResult + " " + intervals[i] + ((divResult > 1) ? "s" : ""));
interval = interval % intervals[i];
if (!longText) {
break;
}
}
}
let intStr = intervalStrings.join(", ");

}
`````` Easy Way

``````function diff_hours(dt2, dt1)
{

var diff =(dt2.getTime() - dt1.getTime()) / 1000;
diff /= (60 * 60);
return Math.abs(Math.round(diff));

}

function diff_minutes(dt2, dt1)
{

var diff =(dt2.getTime() - dt1.getTime()) / 1000;
diff /= (60);
return Math.abs(Math.round(diff));

}

function diff_seconds(dt2, dt1)
{

var diff =(dt2.getTime() - dt1.getTime()) / 1000;
return Math.abs(Math.round(diff));

}

function diff_miliseconds(dt2, dt1)
{

var diff =(dt2.getTime() - dt1.getTime());
return Math.abs(Math.round(diff));

}

dt1 = new Date(2014,10,2);
dt2 = new Date(2014,10,3);
console.log(diff_hours(dt1, dt2));

dt1 = new Date("October 13, 2014 08:11:00");
dt2 = new Date("October 14, 2014 11:13:00");
console.log(diff_hours(dt1, dt2));

console.log(diff_minutes(dt1, dt2));

console.log(diff_seconds(dt1, dt2));

console.log(diff_miliseconds(dt1, dt2));
`````` I call it the "snowman-carl ? method" and I think it's a little more flexible when you need additional timespans like weeks, moths, years, centuries... and don't want too much repetitive code:

``````var d = Math.abs(date_future - date_now) / 1000;                           // delta
var r = {};                                                                // result
var s = {                                                                  // structure
year: 31536000,
month: 2592000,
week: 604800, // uncomment row to ignore
hour: 3600,
minute: 60,
second: 1
};

Object.keys(s).forEach(function(key){
r[key] = Math.floor(d / s[key]);
d -= r[key] * s[key];
});

// for example: {year:0,month:0,week:1,day:2,hour:34,minute:56,second:7}
console.log(r);
`````` Use moment.js library, for example:

``````var time = date_future - date_now;
var seconds = moment.duration(time).seconds();
var minutes = moment.duration(time).minutes();
var hours   = moment.duration(time).hours();
var days    = moment.duration(time).days();
`````` ``````function calculateExamRemainingTime(exam_end_at) {

\$(function(){

const calcNewYear = setInterval(function(){

const exam_ending_at    = new Date(exam_end_at);
const current_time      = new Date();

const totalSeconds     = Math.floor((exam_ending_at - (current_time))/1000);;
const totalMinutes     = Math.floor(totalSeconds/60);
const totalHours       = Math.floor(totalMinutes/60);
const totalDays        = Math.floor(totalHours/24);

const hours   = totalHours - ( totalDays * 24 );
const minutes = totalMinutes - ( totalDays * 24 * 60 ) - ( hours * 60 );
const seconds = totalSeconds - ( totalDays * 24 * 60 * 60 ) - ( hours * 60 * 60 ) - ( minutes * 60 );

const examRemainingMinutesSection = document.querySelector('#remainingMinutes');
const examRemainingSecondsSection = document.querySelector('#remainingSeconds');

examRemainingMinutesSection.innerHTML = minutes.toString();
examRemainingSecondsSection.innerHTML = seconds.toString();

},1000);
});
}

calculateExamRemainingTime('2025-06-03 20:20:20');
``````