# How to calculate the difference between two dates using PHP? [Answered]

### Sample query:

I have two dates of the form:

``````Start Date: 2007-03-24
End Date: 2009-06-26
``````

Now I need to find the difference between these two in the following form:

``````2 years, 3 months and 2 days
``````

How can I do this in PHP?

## How to calculate the difference between two dates using PHP? Answer #1:

I suggest using DateTime and DateInterval objects.

``````\$date1 = new DateTime("2007-03-24");
\$date2 = new DateTime("2009-06-26");
\$interval = \$date1->diff(\$date2);
echo "difference " . \$interval->y . " years, " . \$interval->m." months, ".\$interval->d." days ";

// shows the total amount of days (not divided into years, months and days like above)
echo "difference " . \$interval->days . " days ";
``````

From the manual:

As of PHP 5.2.2, DateTime objects can be compared using comparison operators.

``````\$date1 = new DateTime("now");
\$date2 = new DateTime("tomorrow");

var_dump(\$date1 == \$date2); // bool(false)
var_dump(\$date1 < \$date2);  // bool(true)
var_dump(\$date1 > \$date2);  // bool(false)``````

## Calculate difference between dates in PHP- Answer #2:

Use this for legacy code (PHP < 5.3). For up to date solution see jurka’s answer below

You can use strtotime() to convert two dates to unix time and then calculate the number of seconds between them. From this it’s rather easy to calculate different time periods.

``````\$date1 = "2007-03-24";
\$date2 = "2009-06-26";

\$diff = abs(strtotime(\$date2) - strtotime(\$date1));

\$years = floor(\$diff / (365*60*60*24));
\$months = floor((\$diff - \$years * 365*60*60*24) / (30*60*60*24));
\$days = floor((\$diff - \$years * 365*60*60*24 - \$months*30*60*60*24)/ (60*60*24));

printf("%d years, %d months, %d days\n", \$years, \$months, \$days);
``````

Edit: Obviously the preferred way of doing this is like described by jurka below. My code is generally only recommended if you don’t have PHP 5.3 or better.

Several people in the comments have pointed out that the code above is only an approximation. I still believe that for most purposes that’s fine, since the usage of a range is more to provide a sense of how much time has passed or remains rather than to provide precision – if you want to do that, just output the date.

Despite all that, I’ve decided to address the complaints. If you truly need an exact range but haven’t got access to PHP 5.3, use the code below (it should work in PHP 4 as well). This is a direct port of the code that PHP uses internally to calculate ranges, with the exception that it doesn’t take daylight savings time into account. That means that it’s off by an hour at most, but except for that it should be correct.

``````<?php

/**
* Calculate differences between two dates with precise semantics. Based on PHPs DateTime::diff()
* implementation by Derick Rethans. Ported to PHP by Emil H, 2011-05-02. No rights reserved.
*
* See here for original code:
*
*
*/

function _date_range_limit(\$start, \$end, \$adj, \$a, \$b, \$result)
{
if (\$result[\$a] < \$start) {
\$result[\$b] -= intval((\$start - \$result[\$a] - 1) / \$adj) + 1;
\$result[\$a] += \$adj * intval((\$start - \$result[\$a] - 1) / \$adj + 1);
}

if (\$result[\$a] >= \$end) {
}

return \$result;
}

function _date_range_limit_days(\$base, \$result)
{
\$days_in_month_leap = array(31, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31);
\$days_in_month = array(31, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31);

_date_range_limit(1, 13, 12, "m", "y", &\$base);

\$year = \$base["y"];
\$month = \$base["m"];

if (!\$result["invert"]) {
while (\$result["d"] < 0) {
\$month--;
if (\$month < 1) {
\$month += 12;
\$year--;
}

\$leapyear = \$year % 400 == 0 || (\$year % 100 != 0 && \$year % 4 == 0);
\$days = \$leapyear ? \$days_in_month_leap[\$month] : \$days_in_month[\$month];

\$result["d"] += \$days;
\$result["m"]--;
}
} else {
while (\$result["d"] < 0) {
\$leapyear = \$year % 400 == 0 || (\$year % 100 != 0 && \$year % 4 == 0);
\$days = \$leapyear ? \$days_in_month_leap[\$month] : \$days_in_month[\$month];

\$result["d"] += \$days;
\$result["m"]--;

\$month++;
if (\$month > 12) {
\$month -= 12;
\$year++;
}
}
}

return \$result;
}

function _date_normalize(\$base, \$result)
{
\$result = _date_range_limit(0, 60, 60, "s", "i", \$result);
\$result = _date_range_limit(0, 60, 60, "i", "h", \$result);
\$result = _date_range_limit(0, 24, 24, "h", "d", \$result);
\$result = _date_range_limit(0, 12, 12, "m", "y", \$result);

\$result = _date_range_limit_days(&\$base, &\$result);

\$result = _date_range_limit(0, 12, 12, "m", "y", \$result);

return \$result;
}

/**
* Accepts two unix timestamps.
*/
function _date_diff(\$one, \$two)
{
\$invert = false;
if (\$one > \$two) {
list(\$one, \$two) = array(\$two, \$one);
\$invert = true;
}

\$key = array("y", "m", "d", "h", "i", "s");
\$a = array_combine(\$key, array_map("intval", explode(" ", date("Y m d H i s", \$one))));
\$b = array_combine(\$key, array_map("intval", explode(" ", date("Y m d H i s", \$two))));

\$result = array();
\$result["y"] = \$b["y"] - \$a["y"];
\$result["m"] = \$b["m"] - \$a["m"];
\$result["d"] = \$b["d"] - \$a["d"];
\$result["h"] = \$b["h"] - \$a["h"];
\$result["i"] = \$b["i"] - \$a["i"];
\$result["s"] = \$b["s"] - \$a["s"];
\$result["invert"] = \$invert ? 1 : 0;
\$result["days"] = intval(abs((\$one - \$two)/86400));

if (\$invert) {
_date_normalize(&\$a, &\$result);
} else {
_date_normalize(&\$b, &\$result);
}

return \$result;
}

\$date = "1986-11-10 19:37:22";

print_r(_date_diff(strtotime(\$date), time()));
print_r(_date_diff(time(), strtotime(\$date)));
``````

The best course of action is using PHP’s `DateTime` (and `DateInterval`) objects. Each date is encapsulated in a `DateTime` object, and then a difference between the two can be made:

``````\$first_date = new DateTime("2012-11-30 17:03:30");
\$second_date = new DateTime("2012-12-21 00:00:00");
``````

The `DateTime` object will accept any format `strtotime()` would. If an even more specific date format is needed, `DateTime::createFromFormat()` can be used to create the `DateTime` object.

After both objects were instantiated, you substract one from the other with `DateTime::diff()`.

``````\$difference = \$first_date->diff(\$second_date);
``````

`\$difference` now holds a `DateInterval` object with the difference information. A `var_dump()` looks like this:

``````object(DateInterval)
public 'y' => int 0
public 'm' => int 0
public 'd' => int 20
public 'h' => int 6
public 'i' => int 56
public 's' => int 30
public 'invert' => int 0
public 'days' => int 20
``````

To format the `DateInterval` object, we’ll need to check each value and exclude it if it’s 0:

``````/**
* Format an interval to show all existing components.
* If the interval doesn't have a time component (years, months, etc)
* That component won't be displayed.
*
* @param DateInterval \$interval The interval
*
* @return string Formatted interval string.
*/
function format_interval(DateInterval \$interval) {
\$result = "";
if (\$interval->y) { \$result .= \$interval->format("%y years "); }
if (\$interval->m) { \$result .= \$interval->format("%m months "); }
if (\$interval->d) { \$result .= \$interval->format("%d days "); }
if (\$interval->h) { \$result .= \$interval->format("%h hours "); }
if (\$interval->i) { \$result .= \$interval->format("%i minutes "); }
if (\$interval->s) { \$result .= \$interval->format("%s seconds "); }

return \$result;
}
``````

All that’s left now is to call our function on the `\$difference` `DateInterval` object:

``````echo format_interval(\$difference);
``````

And we get the correct result:

20 days 6 hours 56 minutes 30 seconds

The complete code used to achieve the goal:

``````/**
* Format an interval to show all existing components.
* If the interval doesn't have a time component (years, months, etc)
* That component won't be displayed.
*
* @param DateInterval \$interval The interval
*
* @return string Formatted interval string.
*/
function format_interval(DateInterval \$interval) {
\$result = "";
if (\$interval->y) { \$result .= \$interval->format("%y years "); }
if (\$interval->m) { \$result .= \$interval->format("%m months "); }
if (\$interval->d) { \$result .= \$interval->format("%d days "); }
if (\$interval->h) { \$result .= \$interval->format("%h hours "); }
if (\$interval->i) { \$result .= \$interval->format("%i minutes "); }
if (\$interval->s) { \$result .= \$interval->format("%s seconds "); }

return \$result;
}

\$first_date = new DateTime("2012-11-30 17:03:30");
\$second_date = new DateTime("2012-12-21 00:00:00");

\$difference = \$first_date->diff(\$second_date);

echo format_interval(\$difference);``````

View Hours and Minuts and Seconds..

``````\$date1 = "2008-11-01 22:45:00";

\$date2 = "2009-12-04 13:44:01";

\$diff = abs(strtotime(\$date2) - strtotime(\$date1));

\$years   = floor(\$diff / (365*60*60*24));
\$months  = floor((\$diff - \$years * 365*60*60*24) / (30*60*60*24));
\$days    = floor((\$diff - \$years * 365*60*60*24 - \$months*30*60*60*24)/ (60*60*24));

\$hours   = floor((\$diff - \$years * 365*60*60*24 - \$months*30*60*60*24 - \$days*60*60*24)/ (60*60));

\$minuts  = floor((\$diff - \$years * 365*60*60*24 - \$months*30*60*60*24 - \$days*60*60*24 - \$hours*60*60)/ 60);

\$seconds = floor((\$diff - \$years * 365*60*60*24 - \$months*30*60*60*24 - \$days*60*60*24 - \$hours*60*60 - \$minuts*60));

printf("%d years, %d months, %d days, %d hours, %d minuts\n, %d seconds\n", \$years, \$months, \$days, \$hours, \$minuts, \$seconds);
``````

This is the best answer I’ve found so far.. 🙂

``````function dateDiff (\$d1, \$d2) {

// Return the number of days between the two dates:
return round(abs(strtotime(\$d1) - strtotime(\$d2))/86400);

} // end function dateDiff
``````

It doesn’t matter which date is earlier or later when you pass in the date parameters. The function uses the PHP ABS() absolute value to always return a postive number as the number of days between the two dates.

Keep in mind that the number of days between the two dates is NOT inclusive of both dates. So if you are looking for the number of days represented by all the dates between and including the dates entered, you will need to add one (1) to the result of this function.

For example, the difference (as returned by the above function) between 2013-02-09 and 2013-02-14 is 5. But the number of days or dates represented by the date range 2013-02-09 – 2013-02-14 is 6.

## Example code to find the difference between two dates in PHP- Answer #6:

``````<?php
\$today = strtotime("2011-02-03 00:00:00");
\$myBirthDate = strtotime("1964-10-30 00:00:00");
printf("Days since my birthday: ", (\$today - \$myBirthDate)/60/60/24);
?>``````

## For PHP 5.3- Answer #7:

I found myself working on a similar problem – which is how I got to this question in the first place – but just needed a difference in hours. But my function solved this one pretty nicely as well and I don’t have anywhere in my own library to keep it where it won’t get lost and forgotten, so… hope this is useful to someone.

``````/**
*
* @param DateTime \$oDate1
* @param DateTime \$oDate2
* @return array
*/
function date_diff_array(DateTime \$oDate1, DateTime \$oDate2) {
\$aIntervals = array(
'year'   => 0,
'month'  => 0,
'week'   => 0,
'day'    => 0,
'hour'   => 0,
'minute' => 0,
'second' => 0,
);

foreach(\$aIntervals as \$sInterval => &\$iInterval) {
while(\$oDate1 <= \$oDate2){
\$oDate1->modify('+1 ' . \$sInterval);
if (\$oDate1 > \$oDate2) {
\$oDate1->modify('-1 ' . \$sInterval);
break;
} else {
\$iInterval++;
}
}
}

return \$aIntervals;
}
``````

And the test:

``````\$oDate = new DateTime();
\$oDate->modify('+111402189 seconds');
var_dump(\$oDate);
var_dump(date_diff_array(new DateTime(), \$oDate));
``````

And the result:

``````object(DateTime)[2]
public 'date' => string '2014-04-29 18:52:51' (length=19)
public 'timezone_type' => int 3
public 'timezone' => string 'America/New_York' (length=16)

array
'year'   => int 3
'month'  => int 6
'week'   => int 1
'day'    => int 4
'hour'   => int 9
'minute' => int 3
'second' => int 8
``````

I got the original idea from here, which I modified for my uses (and I hope my modification will show on that page as well).

You can very easily remove intervals you don’t want (say “week”) by removing them from the `\$aIntervals` array, or maybe adding an `\$aExclude` parameter, or just filter them out when you output the string.

### Use example :

``````echo time_diff_string('2013-05-01 00:22:35', 'now');
echo time_diff_string('2013-05-01 00:22:35', 'now', true);
``````

### Output :

``````4 months ago
4 months, 2 weeks, 3 days, 1 hour, 49 minutes, 15 seconds ago
``````

### Function :

``````function time_diff_string(\$from, \$to, \$full = false) {
\$from = new DateTime(\$from);
\$to = new DateTime(\$to);
\$diff = \$to->diff(\$from);

\$diff->w = floor(\$diff->d / 7);
\$diff->d -= \$diff->w * 7;

\$string = array(
'y' => 'year',
'm' => 'month',
'w' => 'week',
'd' => 'day',
'h' => 'hour',
'i' => 'minute',
's' => 'second',
);
foreach (\$string as \$k => &\$v) {
if (\$diff->\$k) {
\$v = \$diff->\$k . ' ' . \$v . (\$diff->\$k > 1 ? 's' : '');
} else {
unset(\$string[\$k]);
}
}

if (!\$full) \$string = array_slice(\$string, 0, 1);
return \$string ? implode(', ', \$string) . ' ago' : 'just now';
}``````

Hope you learned something from this post.