Wie finde ich mit PHP die Anzahl der Tage zwischen zwei Daten?

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

echo round($datediff / (60 * 60 * 24));

Wenn Sie verwenden PHP 5.3 >, ist dies bei weitem die genaueste Methode zur Berechnung der Differenz:

$earlier = new DateTime("2010-07-06");
$later = new DateTime("2010-07-09");

$diff = $later->diff($earlier)->format("%a");

Ab PHP Version 5.3 wurden neue Datums- / Uhrzeitfunktionen hinzugefügt, um Unterschiede zu erzielen:

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

Ergebnis wie folgt:

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
)

Ich hoffe es hilft !

Konvertieren Sie Ihre Daten in Unix-Zeitstempel und subtrahieren Sie sie dann voneinander. Dies gibt Ihnen die Differenz in Sekunden, die Sie durch 86400 (Anzahl der Sekunden pro Tag) dividieren, um eine ungefähre Anzahl von Tagen in diesem Bereich zu erhalten.

Wenn Ihre Daten im Format oder vorliegen 25.1.2010, können Sie die folgende Funktion verwenden:01/25/20102010-01-25strtotime

$start = strtotime('2010-01-25');
$end = strtotime('2010-02-20');

$days_between = ceil(abs($end - $start) / 86400);

Mit ceilRunden die Anzahl der Tage bis zum nächsten vollen Tag. Verwenden Sie floorstattdessen, wenn Sie die Anzahl der vollen Tage zwischen diesen beiden Daten abrufen möchten.

Wenn Ihre Daten bereits im Unix-Zeitstempelformat vorliegen, können Sie die Konvertierung überspringen und nur den $days_betweenTeil ausführen . Für exotischere Datumsformate müssen Sie möglicherweise eine benutzerdefinierte Analyse durchführen, um die richtigen Ergebnisse zu erzielen.

TL; DR verwenden keine UNIX-Zeitstempel. Nicht verwendentime() . Wenn Sie dies tun, sollten Sie darauf vorbereitet sein, wenn die Zuverlässigkeit von 98,0825% Sie nicht erfüllt. Verwenden Sie DateTime (oder Carbon).

Die richtige Antwort ist die von Saksham Gupta (andere Antworten sind auch richtig):

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

Oder prozedural als Einzeiler:

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

Mit einer Einschränkung: Das '% a' scheint die absolute Anzahl von Tagen anzugeben . Wenn Sie es als vorzeichenbehaftete Ganzzahl möchten, dh negativ, wenn das zweite Datum vor dem ersten liegt, müssen Sie das Präfix '% r' (dh format('%r%a')) verwenden.

Wenn Sie wirklich UNIX-Zeitstempel verwenden müssen, stellen Sie die Zeitzone auf GMT ein , um die meisten der unten aufgeführten Fallstricke zu vermeiden .

Lange Antwort: Warum das Teilen durch 24 * 60 * 60 (auch bekannt als 86400) unsicher ist

Die meisten Antworten, die UNIX-Zeitstempel verwenden (und 86400, um diese in Tage umzuwandeln), gehen von zwei Annahmen aus, die zusammengenommen zu Szenarien mit falschen Ergebnissen und subtilen Fehlern führen können , die möglicherweise schwer zu verfolgen sind und sogar Tage, Wochen oder Monate später auftreten eine erfolgreiche Bereitstellung. Es ist nicht so, dass die Lösung nicht funktioniert - es funktioniert. Heute. Aber es könnte morgen aufhören zu arbeiten.

Der erste Fehler besteht nicht darin, dass ein Computer bei der Frage "Wie viele Tage sind seit gestern vergangen?" Wahrhaftig mit Null antworten kann, wenn zwischen der Gegenwart und dem durch "gestern" angegebenen Moment weniger als ein ganzer Tag vergangen ist.

Wenn Sie einen "Tag" in einen UNIX-Zeitstempel konvertieren, erhalten Sie normalerweise den Zeitstempel für die Mitternacht dieses bestimmten Tages.

Zwischen der Mitte des 1. und 15. Oktober sind also fünfzehn Tage vergangen. Zwischen 13:00 Uhr am 1. Oktober und 14:55 Uhr am 15. Oktober sind jedoch fünfzehn Tage minus 5 Minuten vergangen, und die meisten Lösungen, floor()die eine implizite Ganzzahlkonvertierung verwenden oder durchführen, melden einen Tag weniger als erwartet .

Also, "vor wie vielen Tagen war Ymd H: i: s"? wird die falsche Antwort geben .

Der zweite Fehler entspricht einem Tag 86400 Sekunden. Dies ist fast immer der Fall - es passiert oft genug, um die Zeiten zu übersehen, in denen dies nicht der Fall ist. Aber der Abstand in Sekunden zwischen zwei aufeinanderfolgenden Mitternächten beträgt sicherlich nicht mindestens zweimal im Jahr 86400, wenn die Sommerzeit ins Spiel kommt. Wenn Sie zwei Daten über eine Sommerzeitgrenze hinweg vergleichen, erhalten Sie die falsche Antwort.

Selbst wenn Sie den "Hack" verwenden, um alle Datumszeitstempel auf eine feste Stunde zu zwingen, z. B. Mitternacht (dies geschieht implizit auch durch verschiedene Sprachen und Frameworks, wenn Sie nur Tag-Monat-Jahr und nicht auch Stunde-Minute-Sekunde angeben. Gleiches gilt für den DATE-Typ in Datenbanken wie MySQL, der weit verbreiteten Formel

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

oder

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

wird beispielsweise 17 zurückgeben, wenn sich DATE1 und DATE2 im selben DST-Segment des Jahres befinden; aber es kann 17.042 und noch schlimmer 16.958 zurückgeben. Die Verwendung von floor () oder einer impliziten Kürzung in eine Ganzzahl konvertiert dann eine 17 in eine 16. Unter anderen Umständen werden Ausdrücke wie "$ days> 17" truefür 17.042 zurückgegeben, selbst wenn dies anzeigt, dass der verstrichene Tag zählt ist 18.

Und die Dinge werden noch hässlicher, da ein solcher Code nicht plattformübergreifend portierbar ist, da einige von ihnen möglicherweise Schaltsekunden anwenden und andere nicht . Auf diesen Plattformen , die nicht die Differenz zwischen zwei Daten, nicht aber 86400 86401, oder vielleicht 86399. sein So - Code, der im Juni nächsten Jahres bricht im Mai und bestanden tatsächlich alle Tests gearbeitet , als 12,99999 Tage 12 Tage statt 13. Zwei Tage , in Betracht gezogen werden dass im Jahr 2015 gearbeitet wird nicht funktionieren , im Jahr 2017 - die gleichen Daten und weder Jahr ein Schaltjahr ist . Aber zwischen dem 01.03.2018 und dem 01.03.2017 sind auf den Plattformen, die sich darum kümmern, 366 Tage statt 365 vergangen, was 2018 zu einem Schaltjahr macht (was es nicht ist).

Wenn Sie also wirklich UNIX-Zeitstempel verwenden möchten:

• Verwenden Sie die round()Funktion mit Bedacht, nicht floor().

• Berechnen Sie alternativ keine Unterschiede zwischen D1-M1-YYY1 und D2-M2-YYY2. Diese Daten werden wirklich als D1-M1-YYY1 00:00:00 und D2-M2-YYY2 00:00:00 betrachtet. Konvertieren Sie stattdessen zwischen D1-M1-YYY1 22:30:00 und D2-M2-YYY2 04:30:00. Sie erhalten immer einen Rest von etwa zwanzig Stunden. Dies kann einundzwanzig Stunden oder neunzehn und vielleicht achtzehn Stunden, neunundfünfzig Minuten und sechsunddreißig Sekunden werden. Ganz gleich. Es ist eine große Marge, die dort bleiben und auf absehbare Zeit positiv bleiben wird. Jetzt können Sie es mit gestutzt floor()in Sicherheit.

Die richtige Lösung, um magische Konstanten, Rundungen und Wartungsschulden zu vermeiden, ist jedoch

• Verwenden Sie eine Zeitbibliothek (Datetime, Carbon, was auch immer). roll nicht deine eigenen

• Schreiben Sie umfassende Testfälle mit wirklich schlechten Datumsentscheidungen - über Sommerzeitgrenzen hinweg, über Schaltjahre, über Schaltsekunden usw. hinweg sowie über alltägliche Daten. Im Idealfall (Aufrufe von datetime sind schnell !) Generieren Sie Daten im Wert von vier ganzen Jahren (und einem Tag) , indem Sie sie nacheinander aus Zeichenfolgen zusammensetzen, und stellen Sie sicher, dass der Unterschied zwischen dem ersten Tag und dem getesteten Tag stetig um eins zunimmt. Auf diese Weise wird sichergestellt, dass Sie zumindest wissen , ob sich Änderungen an den Routinen auf niedriger Ebene und an Korrekturen in Schaltsekunden ergeben, die Chaos anrichten .

• Führen Sie diese Tests regelmäßig zusammen mit dem Rest der Testsuite aus. Sie sind eine Frage von Millisekunden und können Ihnen buchstäblich Stunden des Kopfkratzens ersparen .

Was auch immer Ihre Lösung ist, testen Sie sie!

Die folgende Funktion funcdiffimplementiert eine der Lösungen (zufällig die akzeptierte) in einem realen Szenario.

<?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 between {$yearFrom} and {$yearTo}.\n";

Das Ergebnis ist,

This function failed 280 of its 14603 tests

Horror Story: Die Kosten für "Zeit sparen"

Dies geschah tatsächlich vor einigen Monaten. Ein genialer Programmierer beschloss, einige Mikrosekunden bei einer Berechnung zu sparen, die höchstens 30 Sekunden dauerte, indem er den berüchtigten Code "(MidnightOfDateB-MidnightOfDateA) / 86400" an mehreren Stellen einfügte. Es war eine so offensichtliche Optimierung, dass er sie nicht einmal dokumentierte, und die Optimierung bestand die Integrationstests und lauerte mehrere Monate lang unbemerkt im Code.

Dies geschah in einem Programm, das die Löhne für mehrere meistverkaufte Verkäufer berechnet, von denen der geringste viel mehr Einfluss hat als ein ganzes bescheidenes fünfköpfiges Programmierteam zusammen. Eines Tages vor einigen Monaten schlug der Fehler aus unerheblichen Gründen zu - und einige dieser Leute hatten einen ganzen Tag lang einen Mangel an fetten Provisionen. Sie waren definitiv nicht amüsiert.

Unendlich schlimmer, sie verloren das (bereits sehr geringe) Vertrauen in das Programm, das nicht dazu gedacht war, sie heimlich zu beschützen, und gaben vor - und erhielten - eine vollständige, detaillierte Codeüberprüfung mit Testfällen, die in Laienbegriffen ausgeführt und kommentiert wurden (plus viel) der Behandlung auf dem roten Teppich in den folgenden Wochen).

Was kann ich sagen: Auf der positiven Seite haben wir eine Menge technischer Schulden beseitigt und konnten mehrere Teile eines Spaghetti-Chaos umschreiben und umgestalten, das auf einen COBOL-Befall in den schwingenden 90ern zurückging. Das Programm läuft jetzt zweifellos besser und es gibt viel mehr Debugging-Informationen, die Sie schnell finden können, wenn etwas faul aussieht. Ich schätze, dass nur diese letzte Sache auf absehbare Zeit vielleicht ein oder zwei Manntage pro Monat einsparen wird.

Auf der negativen Seite kostete das ganze Brouhaha das Unternehmen im Voraus etwa 200.000 Euro - plus Gesicht plus zweifellos etwas Verhandlungsmacht (und damit noch mehr Geld).

Der für die "Optimierung" verantwortliche Mann hatte vor einem Jahr vor der Katastrophe den Job gewechselt, aber es war immer noch die Rede davon, ihn auf Schadensersatz zu verklagen. Und es passte nicht gut zu den oberen Rängen, dass es "die Schuld des letzten Mannes" war - es sah nach einer Vorbereitung für uns aus, um die Angelegenheit zu klären, und am Ende sind wir immer noch in der Hundehütte und einer aus dem Team plant aufzuhören.

Neunundneunzig von einhundert Mal funktioniert der "86400-Hack" einwandfrei. ( strtotime()Ignoriert beispielsweise in PHP die Sommerzeit und meldet, dass zwischen der Nacht des letzten Samstags im Oktober und der des folgenden Montags genau 2 * 24 * 60 * 60 Sekunden vergangen sind, auch wenn dies eindeutig nicht zutrifft ... und zwei Fehler machen glücklich einen richtig).

Dies, meine Damen und Herren, war ein Fall, in dem dies nicht der Fall war. Wie bei Airbags und Sicherheitsgurten werden Sie die Komplexität (und Benutzerfreundlichkeit) von oder vielleicht nie wirklich brauchen . Aber der Tag, an dem Sie könnten (oder der Tag, an dem Sie beweisen müssen, dass Sie darüber nachgedacht haben), wird in der Nacht als Dieb kommen. Sei vorbereitet.DateTimeCarbon

Einfach zu verwenden 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');

• Weitere Informationen finden Sie unter : http://blog.innovsystems.com/php/get-number-days-between-two-dates-php

Objektorientierter Stil:

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

Verfahrensstil:

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

Benutzte dies :)

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

Jetzt funktioniert es

Nun, die ausgewählte Antwort ist nicht die richtigste, da sie außerhalb von UTC fehlschlägt. Abhängig von der Zeitzone ( Liste ) kann es zu Zeitanpassungen kommen, die Tage "ohne" 24 Stunden erzeugen. Dadurch schlägt die Berechnung (60 * 60 * 24) fehl.

Hier ist es ein Beispiel dafür:

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

Die richtige Lösung wird also DateTime verwenden

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

Berechnen Sie die Differenz zwischen zwei Daten:

$date1=date_create("2013-03-15");
$date2=date_create("2013-12-12");

$diff=date_diff($date1,$date2);

echo $diff->format("%R%a days");

Ausgabe: +272 Tage

Die Funktion date_diff () gibt die Differenz zwischen zwei DateTime-Objekten zurück.

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

Ich verwende Carbon in meinen Komponistenprojekten für diesen und ähnliche Zwecke.

So einfach wäre das:

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

Sie können Daten einfach von finden

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

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

und bei Bedarf:

$datediff=abs($datediff);

Wenn Sie die Zeiten in Sekunden haben (IE-Unix-Zeitstempel), können Sie die Zeiten einfach subtrahieren und durch 86400 (Sekunden pro Tag) dividieren.

Anzahl der Tage zwischen zwei Daten 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 "; 

Sie können den folgenden Code ausprobieren:

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

function howManyDays($startDate,$endDate) {

    $date1  = strtotime($startDate." 0:00:00");
    $date2  = strtotime($endDate." 23:59:59");
    $res    =  (int)(($date2-$date1)/86400);        

return $res;
} 

Wenn Sie alle Tage zwischen dem Start- und Enddatum wiedergeben möchten, habe ich Folgendes gefunden:

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

Der einfachste Weg, um die Tagesdifferenz zwischen zwei Daten zu ermitteln

$date1 = strtotime("2019-05-25"); 
$date2 = strtotime("2010-06-23");

$date_difference = $date2 - $date1;

$result =  round( $date_difference / (60 * 60 * 24) );

echo $result;

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

Hier ist meine verbesserte Version, die 1 Jahr (e) 2 Monat (e) 25 Tag (e) anzeigt, wenn der 2. Parameter übergeben wird.

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

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

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

benutzte den obigen Code sehr einfach. Vielen Dank.

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

Mit dieser einfachen Funktion. Funktion deklarieren

<?php
function dateDiff($firstDate,$secondDate){
    $firstDate = strtotime($firstDate);
    $secondDate = strtotime($secondDate);

    $datediff = $firstDate - $secondDate;
    $output = round($datediff / (60 * 60 * 24));
    return $output;
}
?>

und rufen Sie diese Funktion so auf, wie Sie möchten

<?php
    echo dateDiff("2018-01-01","2018-12-31");    

// OR

    $firstDate = "2018-01-01";
    $secondDate = "2018-01-01";
    echo dateDiff($firstDate,$secondDate);    
?>

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

Wenn Sie MySQL verwenden

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;

}}

Versuchen Sie es mit Carbon

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

Auch können Sie verwenden

\Carbon\Carbon::parse('')

um ein Objekt mit Carbon-Datum unter Verwendung einer bestimmten Zeitstempelzeichenfolge zu erstellen.

Alle Antworten suchen Ich komponiere universelle Funktion, was auf allen PHP-Versionen funktioniert.

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;

Im Allgemeinen verwende ich 'DateTime', um Tage zwischen zwei Daten zu finden. Wenn jedoch auf einem Server-Setup aus irgendeinem Grund 'DateTime' nicht aktiviert ist, wird eine einfache (aber nicht sichere) Berechnung mit 'strtotime ()' verwendet.