Come trovare il numero di giorni tra due date usando PHP?

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

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

Se stai usando PHP 5.3 >, questo è di gran lunga il modo più accurato per calcolare la differenza:

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

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

Dalla versione 5.3 di PHP e successive, sono state aggiunte nuove funzioni di data / ora per ottenere la differenza:

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

Risultato come di seguito:

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
)

Spero che sia d'aiuto !

Converti le tue date in unix timestamp, quindi sottrai l'una dall'altra. Questo ti darà la differenza in secondi, che dividi per 86400 (quantità di secondi in un giorno) per darti un numero approssimativo di giorni in quell'intervallo.

Se le date in formato 25.1.2010, 01/25/2010o 2010-01-25, è possibile utilizzare la strtotimefunzione di:

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

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

Utilizzando ceilarrotonda il numero di giorni fino al giorno intero successivo. Utilizzare floorinvece se si desidera ottenere la quantità di giorni interi tra quelle due date.

Se le tue date sono già in formato timestamp unix, puoi saltare la conversione e fare semplicemente la $days_betweenparte. Per formati di date più esotici, potrebbe essere necessario eseguire un'analisi personalizzata per farlo correttamente.

TL; DR non non usare timestamp UNIX. Non usaretime() . Se lo fai, sii preparato se la sua affidabilità del 98,0825% non riesce. Usa DateTime (o Carbon).

La risposta corretta è quella data da Saksham Gupta (anche le altre risposte sono corrette):

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

O proceduralmente come one-liner:

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

Con un avvertimento: il '% a' sembra indicare il numero assoluto di giorni. Se lo si desidera come numero intero con segno, ovvero negativo quando la seconda data è precedente alla prima, è necessario utilizzare il prefisso '% r' (ovvero format('%r%a')).

Se è necessario utilizzare i timestamp UNIX, impostare il fuso orario su GMT per evitare la maggior parte delle insidie ​​descritte di seguito.

Risposta lunga: perché dividere per 24 * 60 * 60 (aka 86400) non è sicuro

La maggior parte delle risposte utilizzando i timestamp UNIX (e 86400 per convertirlo in giorni) fanno due ipotesi che, messe insieme, possono portare a scenari con risultati sbagliati e bug sottili che possono essere difficili da tracciare e sorgere anche giorni, settimane o mesi dopo una distribuzione di successo. Non è che la soluzione non funzioni: funziona. Oggi. Ma potrebbe smettere di funzionare domani.

Il primo errore non è quello di considerare che, alla domanda "Quanti giorni sono passati da ieri?", Un computer potrebbe effettivamente rispondere a zero se tra il presente e l'istante indicato da "ieri" è trascorso meno di un giorno intero .

Di solito quando si converte un "giorno" in un timestamp UNIX, ciò che si ottiene è il timestamp per la mezzanotte di quel particolare giorno.

Quindi tra la mezzanotte del 1 ottobre e il 15 ottobre sono trascorsi quindici giorni. Ma tra le 13:00 del 1 ° ottobre e le 14:55 del 15 ottobre, sono trascorsi quindici giorni meno 5 minuti e la maggior parte delle soluzioni che utilizzano floor()o eseguono la conversione di numero intero implicita segnalerà un giorno in meno del previsto .

Quindi, "quanti giorni fa era Ymd H: i: s"? produrrà la risposta sbagliata .

Il secondo errore equivale a un giorno a 86400 secondi. Questo è quasi sempre vero: capita spesso abbastanza da trascurare le volte che non lo è. Ma la distanza in secondi tra due notti di mezzanotte consecutive non è sicuramente 86400 almeno due volte l'anno quando entra in gioco l'ora legale. Il confronto tra due date oltre un limite DST produrrà la risposta sbagliata.

Quindi, anche se usi "l'hack" per forzare tutti i timestamp di data a un'ora fissa, dì mezzanotte (questo è anche implicitamente fatto da varie lingue e framework quando specifichi solo giorno-mese-anno e non anche ora-minuto-secondo; lo stesso accade con il tipo DATE in database come MySQL), la formula ampiamente utilizzata

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

o

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

restituirà, diciamo, 17 quando DATE1 e DATE2 si trovano nello stesso segmento DST dell'anno; ma potrebbe restituire 17.042, e peggio ancora, 16.958. L'uso di floor () o di qualsiasi troncamento implicito in numero intero convertirà quindi quello che avrebbe dovuto essere un 17 in un 16. In altre circostanze, espressioni come "$ giorni> 17" restituiranno true17.042 anche se ciò indica che il giorno trascorso conta ha 18 anni.

E le cose diventano ancora più brutte dal momento che tale codice non è portatile su tutte le piattaforme, perché alcuni di essi potrebbero applicare secondi saltanti e altri no . Su quelle piattaforme che lo fanno , la differenza tra due date non sarà 86400 ma 86401, o forse 86399. Quindi il codice che ha funzionato a maggio e in realtà ha superato tutti i test si interromperà il prossimo giugno quando 12.99999 giorni sono considerati 12 giorni anziché 13. Due date che ha funzionato nel 2015 non funzionerà nel 2017, le stesse date e nessuno dei due è un anno bisestile. Ma tra il 01-03-2018 e il 01-01-2017, su quelle piattaforme che interessano, saranno trascorsi 366 giorni anziché 365, rendendo il 2018 un anno bisestile (che non lo è).

Quindi, se vuoi davvero usare i timestamp UNIX:

• usa la round()funzione saggiamente, no floor().

• in alternativa, non calcolare le differenze tra D1-M1-YYY1 e D2-M2-YYY2. Tali date saranno considerate come D1-M1-YYY1 00:00:00 e D2-M2-YYY2 00:00:00. Piuttosto, converti tra D1-M1-YYY1 22:30:00 e D2-M2-YYY2 04:30:00. Avrai sempre un resto di circa venti ore. Questo può diventare ventuno o diciannove, e forse diciotto ore, cinquantanove minuti trentasei secondi. Non importa. È un ampio margine che rimarrà lì e rimarrà positivo per il prossimo futuro. Ora puoi troncarlo floor()in sicurezza.

La soluzione corretta però, per evitare costanti magiche, arrotondare i kludges e un debito di mantenimento, è farlo

• utilizzare una libreria temporale (Datetime, Carbon, qualunque cosa); non rotolare il tuo

• scrivere casi di test completi usando scelte di date davvero malvagie - oltre i confini dell'ora legale, attraverso gli anni bisestili, i secondi bisestili e così via, così come le date ordinarie. Idealmente (le chiamate al datetime sono veloci !) Generano quattro interi anni (e un giorno) di date assemblandole da stringhe, in sequenza, e assicurano che la differenza tra il primo giorno e il giorno in esame aumenti costantemente di una. Questo assicurerà che se qualcosa cambia nelle routine di basso livello e correzioni dei secondi bisestili, provi a creare scompiglio, almeno lo saprai .

• eseguire questi test regolarmente insieme al resto della suite di test. Sono una questione di millisecondi e possono farti letteralmente ore di grattarti la testa.

Qualunque sia la tua soluzione, provala!

La funzione funcdiffseguente implementa una delle soluzioni (come accade, quella accettata) in uno scenario del mondo reale.

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

Il risultato è

This function failed 280 of its 14603 tests

Horror Story: il costo del "risparmio di tempo"

Questo in realtà è successo alcuni mesi fa. Un ingegnoso programmatore ha deciso di salvare diversi microsecondi da un calcolo che impiegava al massimo una trentina di secondi, inserendo il famigerato codice "(MidnightOfDateB-MidnightOfDateA) / 86400" in diversi punti. È stata un'ottimizzazione così ovvia che non l'ha nemmeno documentata, e l'ottimizzazione ha superato i test di integrazione e si è nascosta nel codice per diversi mesi, il tutto inosservato.

Ciò è accaduto in un programma che calcola i salari di molti venditori più venduti, il più dei quali ha un impatto molto più spaventoso di un intero modesto team di programmatori composto da cinque persone. Un giorno, alcuni mesi fa, per motivi che contano poco, il bug ha colpito - e alcuni di questi ragazzi sono stati scambiati per un'intera giornata di commissioni grasse. Sono stati sicuramente non divertito.

Infinitamente peggio, persero la (già pochissima) fiducia che avevano nel programma non essendo progettato per aggirarli surrettiziamente, e fingevano - e ottenevano - una revisione completa e dettagliata del codice con casi di test eseguiti e commentati nei termini del profano (oltre a molto del trattamento del tappeto rosso nelle settimane successive).

Cosa posso dire: sul lato positivo, ci siamo sbarazzati di molti debiti tecnici e siamo stati in grado di riscrivere e riformattare diversi pezzi di un pasticcio di spaghetti che è stato ricondotto a un'infestazione di COBOL negli anni '90. Il programma ora funziona senza dubbio meglio, e ci sono molte più informazioni di debug per azzerare rapidamente quando qualcosa sembra sospetto. Stimo che solo quest'ultima cosa salverà forse uno o due giorni-uomo al mese per il prossimo futuro.

Sul lato negativo, l'intero brouhaha è costato alla compagnia circa € 200.000 in anticipo - più la faccia, oltre indubbiamente un po 'di potere contrattuale (e, quindi, ancora più soldi).

Il ragazzo responsabile dell '"ottimizzazione" aveva cambiato lavoro un anno fa, prima del disastro, ma si parlava ancora di denunciarlo per danni. E non è andata bene con le alte sfere che è stata "la colpa dell'ultimo ragazzo" - ci è sembrato un set-up per farci ripulire dalla faccenda, e alla fine, siamo ancora nella cuccia e uno del team sta pianificando di smettere.

Novantanove volte su cento, l '"hack 86400" funzionerà alla perfezione. (Ad esempio in PHP, strtotime()ignorerà l'ora legale e segnalerà che tra la mezzanotte dell'ultimo sabato di ottobre e quella del lunedì successivo, sono trascorsi esattamente 2 * 24 * 60 * 60 secondi, anche se chiaramente non è vero ... e due errori faranno felicemente uno giusto).

Questo, onorevoli colleghi, è stato un esempio quando non è stato così. Come per gli airbag e le cinture di sicurezza, forse non avrai mai davvero bisogno della complessità (e della facilità d'uso) di DateTimeo Carbon. Ma il giorno in cui potresti (o il giorno in cui dovrai dimostrare di aver pensato a questo) verrà come un ladro nella notte. Essere preparato.

Facile da usare 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');

• Vedi di più su: http://blog.innovsystems.com/php/get-number-days-between-two-dates-php

Stile orientato agli oggetti:

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

Stile procedurale:

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

Usato questo :)

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

Ora funziona

Bene, la risposta selezionata non è la più corretta perché fallirà al di fuori di UTC. A seconda del fuso orario ( elenco ) potrebbero esserci degli aggiustamenti del tempo che creano giorni "senza" 24 ore, e questo farà fallire il calcolo (60 * 60 * 24).

Eccone un esempio:

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

Quindi la soluzione corretta utilizzerà 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**

Calcola la differenza tra due date:

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

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

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

Uscita: +272 giorni

La funzione date_diff () restituisce la differenza tra due oggetti DateTime.

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

Sto usando Carbon nei miei progetti di compositore per questo e scopi simili.

Sarebbe facile come questo:

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

Puoi trovare le date semplicemente per

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

e, se necessario:

$datediff=abs($datediff);

Se hai i tempi in secondi (IE unix time stamp), puoi semplicemente sottrarre i tempi e dividerli per 86400 (secondi al giorno)

numero di giorni tra due date 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 "; 

Puoi provare il codice qui sotto:

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

Se vuoi fare eco tutti i giorni tra la data di inizio e di fine, ho pensato a questo:

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

Il modo più semplice per trovare la differenza di giorni tra due date

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

Ecco la mia versione migliorata che mostra 1 anno / i 2 mese / i 25 giorno / i se viene passato il 2o parametro.

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

usato il codice sopra molto semplice. Grazie.

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

Usando questa semplice funzione. Dichiara funzione

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

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

e chiama questa funzione in questo modo dove vuoi

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

Se stai usando 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;

}

Prova a usare Carbon

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

Inoltre puoi usare

\Carbon\Carbon::parse('')

per creare un oggetto della data Carbon utilizzando la stringa data / ora specificata.

Guardando tutte le risposte compongo la funzione universale di ciò che funziona su tutte le versioni di 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;

In generale, utilizzo "DateTime" per trovare giorni tra 2 date. Ma se per qualche motivo, in alcune impostazioni del server non è abilitato 'DateTime', utilizzerà un calcolo semplice (ma non sicuro) con 'strtotime ()'.