Hoe vind je het aantal dagen tussen twee datums met PHP?

Antwoord 1, autoriteit 100%

$now = time(); // or your date as well
$your_date = strtotime("2010-01-31");
$datediff = $now - $your_date;
echo round($datediff / (60 * 60 * 24));

Antwoord 2, autoriteit 59%

Als u PHP 5.3 >gebruikt, is dit verreweg de meest nauwkeurige manier om het absolute verschil te berekenen:

$earlier = new DateTime("2010-07-06");
$later = new DateTime("2010-07-09");
$abs_diff = $later->diff($earlier)->format("%a"); //3

Als je een relatief (getekend) aantal dagen nodig hebt, gebruik dan dit:

$earlier = new DateTime("2010-07-06");
$later = new DateTime("2010-07-09");
$pos_diff = $earlier->diff($later)->format("%r%a"); //3
$neg_diff = $later->diff($earlier)->format("%r%a"); //-3

Antwoord 3, autoriteit 18%

Vanaf PHP versie 5.3 en hoger zijn nieuwe datum/tijd-functiestoegevoegd om verschil te krijgen:

$datetime1 = new DateTime("2010-06-20");
$datetime2 = new DateTime("2011-06-22");
$difference = $datetime1->diff($datetime2);
echo 'Difference: '.$difference->y.' years, ' 
                   .$difference->m.' months, ' 
                   .$difference->d.' days';
print_r($difference);

Resultaat zoals hieronder:

Difference: 1 years, 0 months, 2 days
DateInterval Object
(
    [y] => 1
    [m] => 0
    [d] => 2
    [h] => 0
    [i] => 0
    [s] => 0
    [invert] => 0
    [days] => 367
)

Hopelijk helpt het!

Antwoord 4, autoriteit 15%

TL;DRgebruiken geenUNIX-tijdstempels. Gebruik time()niet. Als u dat doet, wees voorbereidals de betrouwbaarheid van 98,0825% u in de steek laat. Gebruik DateTime (of Carbon).

Het juiste antwoordis dat van Saksham Gupta (andere antwoorden zijn ook correct):

$date1 = new DateTime('2010-07-06');
$date2 = new DateTime('2010-07-09');
$days  = $date2->diff($date1)->format('%a');

Of procedureel als oneliner:

/**
 * Number of days between two dates.
 *
 * @param date $dt1    First date
 * @param date $dt2    Second date
 * @return int
 */
function daysBetween($dt1, $dt2) {
    return date_diff(
        date_create($dt2),  
        date_create($dt1)
    )->format('%a');
}

Met een waarschuwing: de ‘%a’ lijkt het absoluteaantal dagen aan te geven. Als u het als een geheel getal met teken wilt, dat wil zeggen negatief als de tweede datum voor de eerste valt, dan moet u het voorvoegsel ‘%r’ gebruiken (dwz format('%r%a')) .

Als u echt UNIX-tijdstempels moet gebruiken, stel de tijdzone in op GMTom de meestevan de hieronder beschreven valkuilen te vermijden.

Lang antwoord: waarom delen door 24*60*60 (ook bekend als 86400) onveilig is

De meeste antwoorden die UNIX-tijdstempels gebruiken (en 86400 om dat om te zetten in dagen) gaan uit van twee veronderstellingen die samen kunnen leiden tot scenario’s met verkeerde resultatenen subtiele bugsdie moeilijk te traceren kunnen zijn en zelfs dagen, weken of maanden na een succesvolle implementatie optreden. Het is niet dat de oplossing niet werkt – het werkt. Vandaag. Maar misschien werkt het morgen niet meer.

De eerste fout is niet dat wanneer gevraagd wordt: “Hoeveel dagen zijn er verstreken sinds gisteren?”, een computer naar waarheid nulkan antwoorden als tussen het heden en het moment aangegeven door “gisteren” minder dan een hele dagis verstreken.

Meestal wordt bij het converteren van een “dag” naar een UNIX-tijdstempel de tijdstempel voor de middernachtvan die specifieke dag verkregen.

Dus tussen middernacht van 1 oktober en 15 oktober zijn er vijftien dagen verstreken. Maar tussen 1 oktober 13:00 en 15 oktober 14:55 zijn vijftien dagen min 5 minutenverstreken, en de meeste oplossingen die floor()gebruiken of impliciete integer-conversie uitvoeren zal één dag minder rapporteren dan verwacht.

Dus, “hoeveel dagen geleden was Y-m-d H:i:s”? levert het verkeerde antwoordop.

De tweede fout is om één dag gelijk te stellen aan 86400 seconden. Dit is bijna altijdwaar – het gebeurt vaak genoeg om de keren dat het niet gebeurt over het hoofd te zien. Maar de afstand in seconden tussen twee opeenvolgende middernachten is zekerniet minstens twee keer per jaar 86400 wanneer zomertijd in het spel komt. Als je twee datums over een zomertijdgrens vergelijkt, krijg je het verkeerde antwoord.

Dus zelfs als je de “hack” gebruikt om alle datum-tijdstempels naar een vast uur te dwingen, bijvoorbeeld middernacht (dit wordt ook impliciet gedaan door verschillende talen en frameworks wanneer je alleen dag-maand-jaar opgeeft en niet ook uur-minuut -second; hetzelfde gebeurt met het DATE-type in databases zoals MySQL), de veelgebruikte formule

FLOOR((unix_timestamp(DATE2) - unix_timestamp(DATE1)) / 86400)

of

floor((time() - strtotime($somedate)) / 86400)

zal bijvoorbeeld 17 teruggeven wanneer DATE1 en DATE2 in hetzelfde DST-segment van het jaar vallen; maar zelfs als het uur:minuut:tweede deel identiek is, kan het argument 17.042 zijn, en erger nog, 16.958 wanneer ze zich in verschillende DST-segmenten bevinden en de tijdzone DST-bewust is. Het gebruik van floor()of een impliciete truncatie naar een geheel getal zal dan wat een 17 had moeten zijn, converteren naar een 16. In andere omstandigheden zullen uitdrukkingen als “$days > 17” truevoor 17.042, zelfs als dit lijkt alsof het aantal verstreken dagen 18 is.

En de dingen worden nog lelijker omdat dergelijke code niet overdraagbaar isop verschillende platforms, omdat sommige kunnen schrikkelseconden toepassen en andere niet. Op die platforms die doen, zal het verschil tussen twee datums niet 86400 maar 86401 zijn, of misschien 86399. Dus code die in mei werkte en daadwerkelijk alle tests heeft doorstaan, zal in juni breken, wanneer 12.99999 dagen als 12 worden beschouwd. dagen in plaats van 13. Twee datums die in 2015 werkten, werken niet in 2017 — de dezelfdedatums, en geen van beide jaren is een schrikkeljaar. En tussen 01-03-2018 en 01-03-2017 zullen er op die platforms 366dagen zijn verstreken in plaats van 365, waardoor 2018 een schrikkeljaar wordt (wat het niet is).

Dus als je echt UNIX-tijdstempels wilt gebruiken:

• gebruik de functie round()verstandig, niet floor().

• Als alternatief, bereken geen verschillen tussen D1-M1-YYY1 en D2-M2-YYY2. Die datums worden echt beschouwd als D1-M1-YYY1 00:00:00 en D2-M2-YYY2 00:00:00. Zet liever om tussen D1-M1-YYY1 22:30:00 en D2-M2-YYY2 04:30:00. U krijgt altijdeen restant van ongeveer twintig uur. Dit kan eenentwintig uur of negentien worden, en misschien achttien uur, negenenvijftig minuten zesendertig seconden. Ongeacht. Het is een grote margedie daar zal blijven en in de nabije toekomst positief zal blijven. Nukun je het veilig afkappen met floor().

De juisteoplossing echter, om magische constanten, afrondingen en een onderhoudsschuld te vermijden, is om

• gebruik een tijdbibliotheek (Datetime, Carbon, wat dan ook); rol niet zelf

• schrijf uitgebreide testcasesmet behulp van echt slechte datumkeuzes – over de zomertijdgrenzen heen, over schrikkeljaren, over schrikkelseconden, enzovoort, evenals gewone datums. Idealiter (aanroepen naar datetime zijn snel!) genereer vier hele jaren (en één dag)aan datums door ze opeenvolgend uit strings te assembleren, en ervoor te zorgen dat het verschil tussen de eerste dag en de dag die wordt getest neemt gestaag toe met één. Dit zorgt ervoor dat als er iets verandert in de routines op laag niveau en schrikkelseconden reparatiesproberen om schade aan te richten, je in ieder geval weet.

• voer deze tests regelmatig uit samen met de rest van de testsuite. Ze zijn een kwestie van milliseconden en kunnen u letterlijk urenhoofd krabben besparen.

Wat je oplossing ook is, test het!

De functie funcdiffhieronder implementeert een van de oplossingen (toevallig de geaccepteerde) in een realistisch scenario.

<?php
$tz         = 'Europe/Rome';
$yearFrom   = 1980;
$yearTo     = 2020;
$verbose    = false;
function funcdiff($date2, $date1) {
    $now        = strtotime($date2);
    $your_date  = strtotime($date1);
    $datediff   = $now - $your_date;
    return floor($datediff / (60 * 60 * 24));
}
########################################
date_default_timezone_set($tz);
$failures   = 0;
$tests      = 0;
$dom = array ( 0, 31, 28, 31, 30,
                  31, 30, 31, 31,
                  30, 31, 30, 31 );
(array_sum($dom) === 365) || die("Thirty days hath September...");
$last   = array();
for ($year = $yearFrom; $year < $yearTo; $year++) {
    $dom[2] = 28;
    // Apply leap year rules.
    if ($year % 4 === 0)   { $dom[2] = 29; }
    if ($year % 100 === 0) { $dom[2] = 28; }
    if ($year % 400 === 0) { $dom[2] = 29; }
    for ($month = 1; $month <= 12; $month ++) {
        for ($day = 1; $day <= $dom[$month]; $day++) {
            $date = sprintf("%04d-%02d-%02d", $year, $month, $day);
            if (count($last) === 7) {
                $tests ++;
                $diff = funcdiff($date, $test = array_shift($last));
                if ((double)$diff !== (double)7) {
                    $failures ++;
                    if ($verbose) {
                        print "There seem to be {$diff} days between {$date} and {$test}\n";
                    }
                }
            }
            $last[] = $date;
        }
    }
}
print "This function failed {$failures} of its {$tests} tests";
print " between {$yearFrom} and {$yearTo}.\n";

Het resultaat is,

This function failed 280 of its 14603 tests

Horrorverhaal: de kosten van “tijd besparen”

Dit is eigenlijk enkele maanden geleden gebeurd. Een ingenieuze programmeur besloot enkele microseconden te besparen op een berekening die hooguit dertig seconden in beslag nam, door op verschillende plaatsen de beruchte “(MidnightOfDateB-MidnightOfDateA)/86400”-code in te pluggen. Het was zo duidelijk een optimalisatie dat hij het niet eens documenteerde, en de optimalisatie doorstond de integratietests en bleef enkele maanden in de code op de loer liggen, allemaal onopgemerkt.

Dit gebeurde in een programma dat de lonen berekent voor verschillende bestverkopende verkopers, waarvan de minste een verschrikkelijk stuk meer invloed heeft dan een heel bescheiden vijfkoppig programmeursteam bij elkaar. Op een dag enkele maanden geleden, om redenen die er niet toe doen, sloeg de bug toe — en sommigevan die jongens kregen een hele dag dikke commissies te kort. Ze waren zeker nietgeamuseerd.

Oneindig erger, ze verloren het (al zeer weinig) vertrouwen dat ze hadden in het programma dat nietwas ontworpen om hen heimelijk te beschieten, en deden alsof – en verkregenen– een complete , gedetailleerde code-review met testgevallen uitgevoerd en becommentarieerd in lekentaal (plus veel rode loperbehandeling in de volgende weken).

Wat kan ik zeggen: aan de positieve kant hebben we veel technische schulden kwijtgescholden en zijn we in staat geweest om verschillende stukjes spaghetti-puinhoop te herschrijven en te herstructureren die teruggrepen op een COBOL-plaag in de swingende jaren ’90. Het programma werkt nu ongetwijfeld beter en er is veel meer foutopsporingsinformatie om snel in te zoomen als iets er raar uitziet. Ik schat dat alleen dit laatste in de nabije toekomst misschien een of twee mandagen per maand zal besparen.

Aan de negatieve kant, de hele brouhaha kostte het bedrijf vooraf ongeveer € 200.000 – plus gezicht, plus ongetwijfeld wat onderhandelingsmacht (en dus nog meer geld).

De man die verantwoordelijk was voor de “optimalisatie” was een jaar geleden, voor de ramp, van baan veranderd, maar er was nog steeds sprake om hem aan te klagen voor schadevergoeding. En het ging niet goed met de hogere regionen dat het “de schuld van de laatste man” was – het leek een opzet voor ons om de zaak schoon te maken, en uiteindelijk zijn we nog steeds in het hondenhok en een van de teamleden is van plan te stoppen.

Negenennegentig van de honderd keer zal de “86400-hack” feilloos werken. (Bijvoorbeeld in PHP, strtotime()negeert DST en meldt dat tussen middernacht van de laatste zaterdag van oktober en die van de volgende maandag precies 2 * 24 * 60 * 60 seconden zijn verstreken , zelfs als dat duidelijk niet waaris… en twee fouten maken er graag één goed).

Dit, dames en heren, was eengeval waarin dit niet het geval was. Net als bij airbags en veiligheidsgordels, zult u de complexiteit (en het gebruiksgemak) van DateTimeof Carbonmisschien nooit echtnodig hebben. Maar de dag waarop je misschien(of de dag waarop je moet bewijzendat je hieraan hebt gedacht) zal als een dief in de nacht komen. Wees voorbereid.

Antwoord 5, autoriteit 14%

Converteer uw datums naar unix-tijdstempels en trek de een van de ander af. Dat geeft je het verschil in seconden, dat je deelt door 86400 (aantal seconden in een dag) om een geschat aantal dagen in dat bereik te krijgen.

Als uw datums de indeling 25.1.2010, 01/25/2010of 01/25/2010hebben, kunt u de strtotimefunctie:

$start = strtotime('2010-01-25');
$end = strtotime('2010-02-20');
$days_between = ceil(abs($end - $start) / 86400);

Als u ceilgebruikt, rondt u het aantal dagen af op de volgende volledige dag. Gebruik in plaats daarvan floorals u het aantal volledige dagen tussen die twee datums wilt hebben.

Als je datums al in unix timestamp-formaat zijn, kun je het converteren overslaan en gewoon het $days_betweengedeelte doen. Voor meer exotische datumnotaties moet je misschien wat aangepaste parsering uitvoeren om het goed te krijgen.

Antwoord 6, autoriteit 2%

Eenvoudig te gebruiken date_diff

$from=date_create(date('Y-m-d'));
$to=date_create("2013-03-15");
$diff=date_diff($to,$from);
print_r($diff);
echo $diff->format('%R%a days');

• Zie voor meer informatie naar: http://blog.innovsystems.com/php / get-nummer-dagen-tussen-twee-data-php

Antwoord 7, Autoriteit 2%

Object-georiënteerde stijl:

$datetime1 = new DateTime('2009-10-11');
$datetime2 = new DateTime('2009-10-13');
$interval = $datetime1->diff($datetime2);
echo $interval->format('%R%a days');

Procedurele stijl:

$datetime1 = date_create('2009-10-11');
$datetime2 = date_create('2009-10-13');
$interval = date_diff($datetime1, $datetime2);
echo $interval->format('%R%a days');

Antwoord 8

Nou, het gekozen antwoord is niet de meest juiste is, omdat het buiten UTC zal mislukken.
Afhankelijk van de tijdzone (lijst ) kunnen er tijd aanpassingen creëren dagen “zonder” 24 uur, en dit zal de berekening (60 * 60 * 24) niet te maken.

Hier is een voorbeeld daarvan:

date_default_timezone_set('europe/lisbon');
$time1 = strtotime('2016-03-27');
$time2 = strtotime('2016-03-29');
echo floor( ($time2-$time1) /(60*60*24));
 ^-- the output will be **1**

Dus de juiste oplossing zal worden met behulp van DateTime

date_default_timezone_set('europe/lisbon');
$date1 = new DateTime("2016-03-27");
$date2 = new DateTime("2016-03-29");
echo $date2->diff($date1)->format("%a");
 ^-- the output will be **2**

Antwoord 9

Gebruikte dit:)

$days = (strtotime($endDate) - strtotime($startDate)) / (60 * 60 * 24);
print $days;

Nu werkt het

Antwoord 10

Bereken het verschil tussen twee data:

$date1=date_create("2013-03-15");
$date2=date_create("2013-12-12");
$diff=date_diff($date1,$date2);
echo $diff->format("%R%a days");

Uitgang:
+272 Days

De functie DATE_DIFF () Retourneert het verschil tussen twee datetime-objecten.

Antwoord 11

$start = '2013-09-08';
$end = '2013-09-15';
$diff = (strtotime($end)- strtotime($start))/24/3600; 
echo $diff;

Antwoord 12

Ik gebruik koolstof in mijn componist-projecten voor deze en soortgelijke doeleinden.

het zou zo eenvoudig zijn als dit:

$dt = Carbon::parse('2010-01-01');
echo $dt->diffInDays(Carbon::now());

Antwoord 13

U kunt data vinden door

<?php
$start  = date_create('1988-08-10');
$end    = date_create(); // Current time and date
$diff   = date_diff( $start, $end );
echo 'The difference is ';
echo  $diff->y . ' years, ';
echo  $diff->m . ' months, ';
echo  $diff->d . ' days, ';
echo  $diff->h . ' hours, ';
echo  $diff->i . ' minutes, ';
echo  $diff->s . ' seconds';
// Output: The difference is 28 years, 5 months, 19 days, 20 hours, 34 minutes, 36 seconds
echo 'The difference in days : ' . $diff->days;
// Output: The difference in days : 10398

Antwoord 14

$datediff = floor(strtotime($date1)/(60*60*24)) - floor(strtotime($date2)/(60*60*24));

en, indien nodig:

$datediff=abs($datediff);

Antwoord 15

aantal dagen tussen twee datums in PHP

     function dateDiff($date1, $date2)  //days find function
        { 
            $diff = strtotime($date2) - strtotime($date1); 
            return abs(round($diff / 86400)); 
        } 
       //start day
       $date1 = "11-10-2018";        
       // end day
       $date2 = "31-10-2018";    
       // call the days find fun store to variable 
       $dateDiff = dateDiff($date1, $date2); 
       echo "Difference between two dates: ". $dateDiff . " Days "; 

Antwoord 16

Als je de tijden in seconden hebt (I.E. Unix-tijdstempel), dan kun je de tijden eenvoudig aftrekken en delen door 86400 (seconden per dag)

Antwoord 17

Je kunt de onderstaande code proberen:

$dt1 = strtotime("2019-12-12"); //Enter your first date
$dt2 = strtotime("12-12-2020"); //Enter your second date
echo abs(($dt1 - $dt2) / (60 * 60 * 24));

Antwoord 18

Gemakkelijkste manier om het verschil van dagen tussen twee datums te vinden

$date1 = strtotime("2019-05-25"); 
$date2 = strtotime("2010-06-23");
$date_difference = $date2 - $date1;
$result =  round( $date_difference / (60 * 60 * 24) );
echo $result;

Antwoord 19

function howManyDays($startDate,$endDate) {
    $date1  = strtotime($startDate." 0:00:00");
    $date2  = strtotime($endDate." 23:59:59");
    $res    =  (int)(($date2-$date1)/86400);        
return $res;
} 

Antwoord 20

Als je alle dagen tussen de start- en einddatum wilt herhalen, heb ik dit bedacht:

$startdatum = $_POST['start']; // starting date
$einddatum = $_POST['eind']; // end date
$now = strtotime($startdatum);
$your_date = strtotime($einddatum);
$datediff = $your_date - $now;
$number = floor($datediff/(60*60*24));
for($i=0;$i <= $number; $i++)
{
    echo date('d-m-Y' ,strtotime("+".$i." day"))."<br>";
}

Antwoord 21

   // Change this to the day in the future
$day = 15;
// Change this to the month in the future
$month = 11;
// Change this to the year in the future
$year = 2012;
// $days is the number of days between now and the date in the future
$days = (int)((mktime (0,0,0,$month,$day,$year) - time(void))/86400);
echo "There are $days days until $day/$month/$year";

Antwoord 22

Hier is mijn verbeterde versie die 1 jaar 2 maand(en) 25 dag(en) laat zien als de 2e parameter wordt doorgegeven.

class App_Sandbox_String_Util {
    /**
     * Usage: App_Sandbox_String_Util::getDateDiff();
     * @param int $your_date timestamp
     * @param bool $hr human readable. e.g. 1 year(s) 2 day(s)
     * @see http://stackoverflow.com/questions/2040560/finding-the-number-of-days-between-two-dates
     * @see http://qSandbox.com
     */
    static public function getDateDiff($your_date, $hr = 0) {
        $now = time(); // or your date as well
        $datediff = $now - $your_date;
        $days = floor( $datediff / ( 3600 * 24 ) );
        $label = '';
        if ($hr) {
            if ($days >= 365) { // over a year
                $years = floor($days / 365);
                $label .= $years . ' Year(s)';
                $days -= 365 * $years;
            }
            if ($days) {
                $months = floor( $days / 30 );
                $label .= ' ' . $months . ' Month(s)';
                $days -= 30 * $months;
            }
            if ($days) {
                $label .= ' ' . $days . ' day(s)';
            }
        } else {
            $label = $days;
        }
        return $label;
    }
}

Antwoord 23

$early_start_date = date2sql($_POST['early_leave_date']);
$date = new DateTime($early_start_date);
$date->modify('+1 day');
$date_a = new DateTime($early_start_date . ' ' . $_POST['start_hr'] . ':' . $_POST['start_mm']);
$date_b = new DateTime($date->format('Y-m-d') . ' ' . $_POST['end_hr'] . ':' . $_POST['end_mm']);
$interval = date_diff($date_a, $date_b);
$time = $interval->format('%h:%i');
$parsed = date_parse($time);
$seconds = $parsed['hour'] * 3600 + $parsed['minute'] * 60;
//        display_error($seconds);
$second3 = $employee_information['shift'] * 60 * 60;
if ($second3 < $seconds)
    display_error(_('Leave time can not be greater than shift time.Please try again........'));
    set_focus('start_hr');
    set_focus('end_hr');
    return FALSE;
}

Antwoord 24

<?php
$date1=date_create("2013-03-15");
$date2=date_create("2013-12-12");
$diff=date_diff($date1,$date2);
echo $diff->format("%R%a days");
?>

gebruikte de bovenstaande code heel eenvoudig. Bedankt.

Antwoord 25

function get_daydiff($end_date,$today)
{
    if($today=='')
    {
        $today=date('Y-m-d');
    }
    $str = floor(strtotime($end_date)/(60*60*24)) - floor(strtotime($today)/(60*60*24));
    return $str;
}
$d1 = "2018-12-31";
$d2 = "2018-06-06";
echo get_daydiff($d1, $d2);

Antwoord 26

Met deze eenvoudige functie. Functie declareren

<?php
function dateDiff($firstDate,$secondDate){
    $firstDate = strtotime($firstDate);
    $secondDate = strtotime($secondDate);
    $datediff = $firstDate - $secondDate;
    $output = round($datediff / (60 * 60 * 24));
    return $output;
}
?>

en noem deze functie zo waar je wilt

<?php
    echo dateDiff("2018-01-01","2018-12-31");    
// OR
    $firstDate = "2018-01-01";
    $secondDate = "2018-01-01";
    echo dateDiff($firstDate,$secondDate);    
?>

Antwoord 27

$diff = strtotime('2019-11-25') - strtotime('2019-11-10');
echo abs(round($diff / 86400));

Antwoord 28

Als u MySql gebruikt

function daysSince($date, $date2){
$q = "SELECT DATEDIFF('$date','$date2') AS days;";
$result = execQ($q);
$row = mysql_fetch_array($result,MYSQL_BOTH);
return ($row[0]);

}

function execQ($q){
$result = mysql_query( $q);
if(!$result){echo ('Database error execQ' . mysql_error());echo $q;}    
return $result;

}

Antwoord 29

Probeer koolstof te gebruiken

$d1 = \Carbon\Carbon::now()->subDays(92);
$d2 = \Carbon\Carbon::now()->subDays(10);
$days_btw = $d1->diffInDays($d2);

U kunt ook

. gebruiken

\Carbon\Carbon::parse('')

om een object van Carbon-datum te maken met behulp van een gegeven tijdstempeltekenreeks.

Antwoord 30

Kijkend naar alle antwoorden stel ik een universele functie samen die werkt op alle PHP-versies.

if(!function_exists('date_between')) :
    function date_between($date_start, $date_end)
    {
        if(!$date_start || !$date_end) return 0;
        if( class_exists('DateTime') )
        {
            $date_start = new DateTime( $date_start );
            $date_end   = new DateTime( $date_end );
            return $date_end->diff($date_start)->format('%a');
        }
        else
        {           
            return abs( round( ( strtotime($date_start) - strtotime($date_end) ) / 86400 ) );
        }
    }
endif;

Over het algemeen gebruik ik ‘DateTime’ om dagen tussen 2 datums te vinden. Maar als om de een of andere reden een serverconfiguratie ‘DateTime’ niet heeft ingeschakeld, zal het een eenvoudige (maar niet veilige) berekening gebruiken met ‘strtotime()’.