Jak znaleźć liczbę dni między dwiema datami za pomocą PHP?

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

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

Jeśli używasz PHP 5.3 >, jest to zdecydowanie najdokładniejszy sposób obliczenia różnicy:

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

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

Od wersji PHP 5.3 i nowszych dodano nowe funkcje daty / godziny, aby uzyskać różnicę:

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

Wynik jak poniżej:

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
)

Mam nadzieję, że to pomoże !

Konwertuj daty na uniksowe znaczniki czasu, a następnie odejmij jedną od drugiej. To da ci różnicę w sekundach, którą dzielisz przez 86400 (ilość sekund w ciągu dnia), aby dać przybliżoną liczbę dni w tym zakresie.

Jeśli daty są w formacie 25.1.2010, 01/25/2010lub 2010-01-25możesz użyć strtotimefunkcji:

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

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

Za pomocą ceilzaokrągleń ilość dni do następnego pełnego dnia. Użyj floorzamiast tego, jeśli chcesz uzyskać liczbę pełnych dni między tymi dwiema datami.

Jeśli Twoje daty są już w formacie uniksowego znacznika czasu, możesz pominąć konwersję i po prostu wykonać $days_betweenczęść. W przypadku bardziej egzotycznych formatów dat może być konieczne wykonanie niestandardowej analizy, aby uzyskać właściwy wynik.

TL; DR czy nie używać znaczników czasu UNIX. Nie używaćtime() . Jeśli tak, przygotuj się, jeśli zawiodą cię niezawodność na poziomie 98,0825%. Użyj DateTime (lub Carbon).

Poprawną odpowiedzią jest ta podana przez Saksham Gupta (również inne odpowiedzi są poprawne):

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

Lub proceduralnie jako jedna linijka:

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

Z zastrzeżeniem: „% a” wydaje się wskazywać bezwzględną liczbę dni. Jeśli chcesz, aby była to liczba całkowita ze znakiem, tzn. Ujemna, gdy druga data jest przed pierwszą, musisz użyć przedrostka „% r” (tj format('%r%a').).

Jeśli naprawdę musisz używać znaczników czasu UNIX, ustaw strefę czasową na GMT, aby uniknąć większości pułapek opisanych poniżej.

Długa odpowiedź: dlaczego dzielenie przez 24 * 60 * 60 (aka 86400) jest niebezpieczne

Większość odpowiedzi wykorzystujących znaczniki czasu UNIX (i 86400 do konwersji na dni) przyjmuje dwa założenia, które razem mogą prowadzić do scenariuszy z błędnymi wynikami i subtelnymi błędami, które mogą być trudne do śledzenia, i mogą pojawić się nawet dni, tygodnie lub miesiące później udane wdrożenie. To nie tak, że rozwiązanie nie działa - działa. Dzisiaj. Ale jutro może przestać działać.

Pierwszym błędem nie jest to, że zapytany „ile dni minęło od wczoraj?”, Komputer może zgodnie z prawdą odpowiedzieć na zero, jeśli między teraźniejszością a chwilą wskazaną przez „wczoraj” minął mniej niż jeden cały dzień .

Zwykle podczas konwertowania „dnia” na znacznik czasu UNIX uzyskuje się znacznik czasu o północy tego konkretnego dnia.

Tak więc między północą 1 października a 15 października upłynęło piętnaście dni. Ale między 13:00 1 października a 14:55 15 października upłynęło piętnaście dni minus 5 minut , a większość rozwiązań wykorzystujących floor()lub dokonujących niejawnej konwersji liczb całkowitych zgłosi jeden dzień mniej niż oczekiwano .

Więc „ile dni temu był Ymd H: i: s”? da złą odpowiedź .

Drugi błąd to zrównanie jednego dnia z 86400 sekundami. Jest to prawie zawsze prawda - zdarza się to dość często, aby przeoczyć czasy, których nie ma. Ale odległość w sekundach między dwiema kolejnymi północami z pewnością nie wynosi 86400 co najmniej dwa razy w roku, kiedy zaczyna się czas letni. Porównanie dwóch dat w granicach DST da złą odpowiedź.

Tak więc, nawet jeśli użyjesz „hackowania” wymuszania wszystkich znaczników czasu daty na ustaloną godzinę, powiedzmy północ (dzieje się to również pośrednio przez różne języki i struktury, gdy podajesz tylko dzień-miesiąc-rok, a nie godzinę-minutę-sekundę; tak samo dzieje się z typem DATE w bazach danych, takich jak MySQL), powszechnie stosowana formuła

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

lub

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

zwróci, powiedzmy, 17, gdy DATA1 i DATA2 będą w tym samym segmencie czasu letniego; ale może zwrócić 17.042, a jeszcze gorzej 16.958. Użycie funkcji floor () lub jakiegokolwiek niejawnego skrótu do liczby całkowitej spowoduje następnie konwersję wartości 17 na 16. W innych okolicznościach wyrażenia takie jak „$ dni> 17” powrócą truedo 17.042, nawet jeśli oznacza to, że liczy się upływający dzień ma 18 lat

A sprawy stają się jeszcze brzydsze, ponieważ taki kod nie jest przenośny na różnych platformach, ponieważ niektóre z nich mogą mieć sekundę przestępną, a inne nie . Na tych platformach zrobienia , różnica pomiędzy dwiema datami nie będzie 86400 ale 86401 lub 86399. Może więc kod, który pracował w maju i faktycznie przeszedł wszystkie testy złamie obok czerwca, kiedy 12.99999 dni są uważane za 12 dni zamiast 13. dwiema datami który pracował w 2015 r., nie zadziała w 2017 r. - w tych samych datach i żaden rok nie jest rokiem przestępnym. Ale między 2018-03-01 a 2017-03-01, na tych platformach, które się przejmują, minie 366 dni zamiast 365, dzięki czemu 2018 będzie rokiem przestępnym (co nie jest).

Jeśli więc naprawdę chcesz używać znaczników czasu UNIX:

• używaj round()funkcji mądrze, nie floor().

• alternatywnie nie obliczaj różnic między D1-M1-RRR1 a D2-M2-RRR2. Te daty będą naprawdę uważane za D1-M1-RRR1 00:00:00 i D2-M2-RRR2 00:00:00. Zamiast tego dokonaj konwersji między D1-M1-RRR1 22:30:00 a D2-M2-RRR2 04:30:00. Będziesz zawsze uzyskać pozostałą około dwudziestu godzin. Może to być dwadzieścia jeden godzin lub dziewiętnaście, a może osiemnaście godzin, pięćdziesiąt dziewięć minut trzydzieści sześć sekund. Bez znaczenia. Jest to duży margines, który pozostanie tam i pozostanie pozytywny w dającej się przewidzieć przyszłości. Teraz możesz go floor()bezpiecznie obciąć .

Poprawne rozwiązanie jednak, aby uniknąć magicznych stałych, zaokrąglając kludges i dług konserwacyjnych, jest

• użyj biblioteki czasu (Datetime, Carbon, cokolwiek); nie rzucaj własnym

• pisz obszerne przypadki testowe, używając naprawdę złych wyborów dat - poza granicami czasu letniego, lat przestępnych, sekund przestępnych itd., a także zwykłych dat. Idealnie (połączenia z datetime są szybkie !) Generują daty z całych czterech lat (i jednego dnia), łącząc je kolejno z ciągów znaków i zapewniają, że różnica między pierwszym dniem a testowanym dniem stale rośnie o jeden. Zapewni to, że jeśli cokolwiek zmieni się w procedurach niskiego poziomu i poprawki sekund przestępnych, sieją spustoszenie, przynajmniej będziesz wiedział .

• uruchamiaj te testy regularnie wraz z resztą zestawu testów. Są kwestią milisekund i mogą zaoszczędzić dosłownie godziny drapania głowy.

Niezależnie od wybranego rozwiązania, przetestuj je!

Poniższa funkcja funcdiffimplementuje jedno z rozwiązań (tak się składa, przyjęte) w scenariuszu z prawdziwego świata.

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

Wynik to,

This function failed 280 of its 14603 tests

Horror Story: koszt „oszczędności czasu”

To się wydarzyło kilka miesięcy temu. Pomysłowy programista postanowił zaoszczędzić kilka mikrosekund na obliczeniach, które zajęły najwyżej około trzydzieści sekund, podłączając niesławny kod „(MidnightOfDateB-MidnightOfDateA) / 86400” w kilku miejscach. Optymalizacja była tak oczywista, że ​​nawet jej nie udokumentował, a optymalizacja przeszła testy integracyjne i czaiła się w kodzie przez kilka miesięcy, wszystkie niezauważone.

Stało się tak w programie, który oblicza płace dla kilku najlepiej sprzedających się sprzedawców, z których co najmniej ma o wiele straszniejszą siłę przebicia niż cały skromny pięcioosobowy zespół programistów razem wzięty. Pewnego dnia kilka miesięcy temu, z powodów, które nie mają znaczenia, błąd uderzył - i niektórzy z tych facetów stracili jeden dzień grubych prowizji. Na pewno nie byli rozbawieni.

Nieskończenie gorzej, stracili (już bardzo niewielką) wiarę w program, który nie został zaprojektowany do ukrycia ich, i udawali - i uzyskali - pełną, szczegółową recenzję kodu z uruchomionymi przypadkami testowymi i komentowali w kategoriach laika (plus wiele leczenia czerwonego dywanu w kolejnych tygodniach).

Co mogę powiedzieć: na plus, pozbyliśmy się dużego technicznego długu i byliśmy w stanie przepisać i przeredagować kilka kawałków bałaganu spaghetti, który wrócił do inwazji COBOL w latach 90. Program niewątpliwie działa teraz lepiej i jest o wiele więcej informacji do debugowania, aby szybko wyzerować, gdy coś wygląda podejrzanie. Szacuję, że tylko ta ostatnia rzecz pozwoli zaoszczędzić jeden lub dwa osobodni miesięcznie na dającą się przewidzieć przyszłość.

Z drugiej strony, cała brouhaha kosztowała firmę około 200 000 euro z góry - plus twarz, a także niewątpliwie pewną siłę przetargową (a tym samym jeszcze więcej pieniędzy).

Facet odpowiedzialny za „optymalizację” przed rokiem zmienił pracę przed katastrofą, ale wciąż było o co prosić go o odszkodowanie. A w wyższych sferach nie szło dobrze, że była to „wina ostatniego faceta” - wyglądało to jak ustawienie dla nas, abyśmy rozwiązali sprawę, a ostatecznie wciąż jesteśmy w niełasce i jeden z zespołów planuje odejść.

Dziewięćdziesiąt dziewięć razy na sto „hack 86400” będzie działał bezbłędnie. (Na przykład w PHP strtotime()zignoruje czas letni i zgłosi, że między północą ostatniej soboty października a tą w następny poniedziałek minęły dokładnie 2 * 24 * 60 * 60 sekund, nawet jeśli to po prostu nieprawda ... a dwie krzywdy na szczęście sprawią, że jedna będzie dobra).

Panie i panowie! To był jeden przypadek, kiedy tak się nie stało. Podobnie jak w przypadku poduszek powietrznych i pasów bezpieczeństwa, być może nigdy naprawdę nie potrzebujesz złożoności (i łatwości użytkowania) DateTimelub Carbon. Ale dni, kiedy może (lub dzień, kiedy będziesz musiał udowodnić, myślałeś o tym) przyjdzie jak złodziej w nocy. Być przygotowanym.

Łatwy w użyciu 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');

• Zobacz więcej na: http://blog.innovsystems.com/php/get-number-days-between-two-dates-php

Styl obiektowy:

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

Styl proceduralny:

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

Użyłem tego :)

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

Teraz działa

Cóż, wybrana odpowiedź nie jest najbardziej poprawna, ponieważ nie powiedzie się poza UTC. W zależności od strefy czasowej ( lista ) mogą istnieć korekty czasu, które tworzą dni „bez” 24 godzin, co spowoduje, że obliczenia (60 * 60 * 24) zakończą się niepowodzeniem.

Oto przykład:

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

Tak więc poprawnym rozwiązaniem będzie użycie 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**

Oblicz różnicę między dwiema datami:

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

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

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

Wyjście: +272 dni

Funkcja date_diff () zwraca różnicę między dwoma obiektami DateTime.

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

Używam Carbon w moich projektach kompozytorskich do tego i podobnych celów.

Byłoby to tak proste:

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

Daty można znaleźć po prostu według

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

oraz w razie potrzeby:

$datediff=abs($datediff);

Jeśli masz czasy w sekundach (znacznik czasu IE unix), możesz po prostu odjąć czasy i podzielić przez 86400 (sekund dziennie)

liczba dni między dwiema datami w 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 "; 

Możesz wypróbować poniższy kod:

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

Jeśli chcesz powtarzać wszystkie dni między datą rozpoczęcia i zakończenia, wymyśliłem:

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

Najłatwiejszy sposób na znalezienie różnicy dni między dwiema datami

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

Oto moja ulepszona wersja, która pokazuje 1 rok (lata) 2 miesiąc (y) 25 dni, jeśli drugi parametr został zaliczony.

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

użyłem powyższego kodu bardzo prosto. Dzięki.

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

Korzystanie z tej prostej funkcji. Funkcja deklaracji

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

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

i wywoływaj tę funkcję tak, jak chcesz

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

Jeśli używasz MySql

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;

}

Spróbuj użyć węgla

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

Możesz także użyć

\Carbon\Carbon::parse('')

aby utworzyć obiekt daty Carbon przy użyciu podanego ciągu znacznika czasu.

Szukając wszystkich odpowiedzi piszę uniwersalną funkcję, która działa na wszystkich wersjach PHP.

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;

Ogólnie używam „DateTime”, aby znaleźć dni między 2 datami. Ale jeśli z jakiegoś powodu niektóre konfiguracje serwera nie mają włączonej funkcji „DateTime”, zastosuje proste (ale nie bezpieczne) obliczenia z funkcją „strtotime ()”.