Como encontrar o número de dias entre duas datas 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 você estiver usando PHP 5.3 >, esta é de longe a maneira mais precisa de calcular a diferença:

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

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

A partir da versão 5.3 do PHP, novas funções de data / hora foram adicionadas para obter a diferença:

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

Resultado como abaixo:

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
)

Espero que ajude !

Converta suas datas em timestamps unix e subtraia uma da outra. Isso fornecerá a diferença em segundos, dividida por 86400 (quantidade de segundos em um dia) para fornecer uma quantidade aproximada de dias nesse intervalo.

Se as datas estão no formato 25.1.2010, 01/25/2010ou 2010-01-25, você pode usar a strtotimefunção:

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

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

O uso ceilarredonda a quantidade de dias até o próximo dia inteiro. Use em floorvez disso, se desejar obter a quantidade de dias completos entre essas duas datas.

Se suas datas já estiverem no formato de carimbo de data e hora unix, você pode pular a conversão e apenas fazer a $days_betweenparte. Para formatos de data mais exóticos, talvez você precise fazer uma análise personalizada para fazer a correção.

TL; DR que não usar timestamps UNIX. Não usetime() . Se o fizer, esteja preparado caso sua confiabilidade de 98,0825% falhe. Use DateTime (ou carbono).

A resposta correta é a dada por Saksham Gupta (outras respostas também estão corretas):

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

Ou processualmente como uma linha:

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

Com uma ressalva: o '% a' parece indicar o número absoluto de dias. Se você deseja que ele seja um número inteiro assinado, ou seja, negativo quando a segunda data for anterior à primeira, será necessário usar o prefixo '% r' (ou seja format('%r%a')).

Se você realmente precisar usar os carimbos de data e hora do UNIX, defina o fuso horário como GMT para evitar a maioria das armadilhas detalhadas abaixo.

Resposta longa: por que dividir por 24 * 60 * 60 (aka 86400) é inseguro

A maioria das respostas que usam registros de data e hora do UNIX (e 86400 para convertê-los em dias) faz duas suposições que, juntas, podem levar a cenários com resultados incorretos e bugs sutis que podem ser difíceis de rastrear e podem surgir mesmo dias, semanas ou meses após uma implantação bem-sucedida. Não é que a solução não funcione - ela funciona. Hoje. Mas pode parar de funcionar amanhã.

O primeiro erro é não considerar que, quando perguntado "Quantos dias se passaram desde ontem?", Um computador pode responder com zero a verdade se entre o presente e o instante indicado por "ontem" tiver passado menos de um dia inteiro .

Normalmente, ao converter um "dia" em um registro de data e hora do UNIX, o que é obtido é o registro de data e hora da meia - noite desse dia específico.

Assim, entre a meia-noite de 1º e 15 de outubro, quinze dias se passaram. Porém, entre as 13:00 de 1º de outubro e as 14:55 de 15 de outubro, quinze dias menos 5 minutos se passaram e a maioria das soluções que usam floor()ou realizam conversão implícita de número inteiro relatará um dia menos do que o esperado .

Então, "há quantos dias Ymd H: i: s"? produzirá a resposta errada .

O segundo erro é equiparar um dia a 86400 segundos. Isso quase sempre é verdade - acontece com frequência suficiente para ignorar os momentos em que não acontece. Mas a distância em segundos entre duas noites consecutivas certamente não é 86400 pelo menos duas vezes por ano, quando o horário de verão entra em jogo. A comparação de duas datas em um limite do horário de verão produzirá a resposta errada.

Portanto, mesmo se você usar o "hack" de forçar todos os registros de data e hora para uma hora fixa, diga meia-noite (isso também é feito implicitamente por vários idiomas e estruturas quando você especifica apenas dia-mês-ano e não também hora-minuto-segundo; O mesmo acontece com o tipo DATE em bancos de dados como o MySQL), a fórmula amplamente usada

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

ou

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

retornará, digamos, 17 quando DATE1 e DATE2 estiverem no mesmo segmento de horário de verão do ano; mas pode retornar 17.042 e, pior ainda, 16.958. O uso de floor () ou qualquer truncamento implícito em número inteiro converterá o que deveria ter sido um 17 em um 16. Em outras circunstâncias, expressões como "$ days> 17" retornarão truepara 17.042, mesmo que isso indique que a contagem de dias decorridos tem 18 anos

E as coisas ficam ainda mais feias, pois esse código não é portátil entre plataformas, porque algumas delas podem aplicar segundos bissextos e outras não . Pelos plataformas que fazer , a diferença entre duas datas não será 86400, mas 86401, ou talvez 86399. Assim código que trabalhou em maio e realmente passou todos os testes vai quebrar em Junho próximo, quando 12.99999 dias são considerados 12 dias em vez de 13. Duas datas que trabalhou em 2015 não funcionará em 2017 - nas mesmas datas e nenhum ano é bissexto. Mas entre 01/03/2018 e 01/03/2017, nessas plataformas que se importam, 366 dias terão passado em vez de 365, tornando 2018 um ano bissexto (o que não é).

Portanto, se você realmente deseja usar registros de data e hora do UNIX:

• use a round()função sabiamente, não floor().

• Como alternativa, não calcule as diferenças entre D1-M1-AAAA1 e D2-M2-AAAA2. Essas datas serão realmente consideradas como D1-M1-AAA1 00:00:00 e D2-M2-AAA2 00:00:00. Em vez disso, converta entre D1-M1-AAAA1 22:30:00 e D2-M2-AAA2 04:30:00. Você sempre terá um restante de cerca de vinte horas. Isso pode se tornar vinte e uma horas ou dezenove e talvez dezoito horas, cinquenta e nove minutos e trinta e seis segundos. Não importa. É uma grande margem que permanecerá lá e permanecerá positiva no futuro próximo. Agora você pode truncá-lo com floor()segurança.

A solução correta , porém, para evitar constantes mágicas, arredondar kludges e uma dívida de manutenção, é

• use uma biblioteca de tempo (Datetime, Carbon, qualquer que seja); não role sozinho

• escreva casos de teste abrangentes usando opções de datas realmente ruins - através dos limites do horário de verão, nos anos bissextos, nos segundos bissextos e assim por diante, além de datas comuns. Idealmente (as chamadas para data e hora são rápidas !) Geram quatro anos inteiros (e um dia) de datas, montando-os a partir de seqüências de caracteres, sequencialmente, e assegurando que a diferença entre o primeiro dia e o dia sendo testado aumente constantemente em um. Isso garantirá que, se alguma coisa mudar nas rotinas de baixo nível e nas correções de segundos bissextos, tentar causar estragos, pelo menos você saberá .

• execute esses testes regularmente junto com o restante do conjunto de testes. São uma questão de milissegundos e podem economizar literalmente horas de coçar a cabeça.

Seja qual for a sua solução, teste-a!

A função funcdiffabaixo implementa uma das soluções (por acaso, a aceita) em um cenário do mundo real.

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

O resultado é,

This function failed 280 of its 14603 tests

Horror Story: o custo de "economizar tempo"

Isso realmente aconteceu alguns meses atrás. Um programador engenhoso decidiu economizar vários microssegundos em um cálculo que demorava cerca de trinta segundos, inserindo o código infame "(MidnightOfDateB-MidnightOfDateA) / 86400" em vários lugares. Era uma otimização tão óbvia que ele nem sequer a documentou, e a otimização passou nos testes de integração e se escondeu no código por vários meses, tudo despercebido.

Isso aconteceu em um programa que calcula os salários de vários vendedores mais vendidos, o menor dos quais tem muito mais influência do que uma humilde equipe de programadores, composta por cinco pessoas. Um dia, alguns meses atrás, por razões que pouco importam, o bug ocorreu - e alguns desses caras foram enganados por um dia inteiro de comissões gordas. Eles definitivamente não eram divertiram.

Infinitamente pior, eles perderam a (já muito pouca) fé que tinham no programa, não sendo projetados para fustigá-los clandestinamente e fingiram - e obtiveram - uma revisão completa e detalhada do código com casos de teste executados e comentados em termos de leigos (mais muito tratamento com tapete vermelho nas semanas seguintes).

O que posso dizer: do lado positivo, nos livramos de muitas dívidas técnicas e fomos capazes de reescrever e refatorar várias partes de uma bagunça de espaguete que causou uma infestação de COBOL nos anos 90. Sem dúvida, o programa roda melhor agora, e há muito mais informações de depuração para se concentrar rapidamente quando algo parece suspeito. Estimo que apenas essa última coisa poupará talvez um ou dois homens-dia por mês no futuro próximo.

No lado negativo, todo o dinheiro custou à empresa cerca de € 200.000 na frente - mais a face, além de indubitavelmente algum poder de barganha (e, portanto, ainda mais dinheiro).

O responsável pela "otimização" havia mudado de emprego há um ano, antes do desastre, mas ainda havia conversas para processá-lo por danos. E não foi bem com os escalões superiores o fato de ter sido "a culpa do último cara" - parecia uma armação para resolvermos o problema e, no final, ainda estamos na casa de cachorro e uma equipe está planejando sair.

Noventa e nove vezes em cem, o "86400 hack" funcionará perfeitamente. (Por exemplo, em PHP, strtotime()ignorará o horário de verão e informará que entre a meia-noite do último sábado de outubro e a segunda-feira seguinte, exatamente 2 * 24 * 60 * 60 segundos se passaram, mesmo que isso não seja verdade. ... e dois erros alegremente farão um certo).

Senhoras e Senhores Deputados, este foi um caso em que não aconteceu. Como nos airbags e cintos de segurança, talvez você nunca precise realmente da complexidade (e facilidade de uso) de DateTimeou Carbon. Mas o dia em que você poderá (ou o dia em que terá que provar que pensou sobre isso) virá como um ladrão durante a noite. Esteja preparado.

Fácil de usar 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');

• Veja mais em: http://blog.innovsystems.com/php/get-number-days-between-two-dates-php

Estilo orientado a objetos:

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

Estilo processual:

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

Usou isso :)

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

Agora funciona

Bem, a resposta selecionada não é a mais correta porque falhará fora do UTC. Dependendo do fuso horário ( lista ), pode haver ajustes de tempo criando dias "sem" 24 horas, e isso fará com que o cálculo (60 * 60 * 24) falhe.

Aqui está um exemplo disso:

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

Portanto, a solução correta estará usando 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**

Calcule a diferença entre duas datas:

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

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

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

Saída: +272 dias

A função date_diff () retorna a diferença entre dois objetos DateTime.

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

Estou usando o Carbon nos meus projetos de compositor para esse e outros propósitos semelhantes.

Seria tão fácil assim:

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

Você pode encontrar datas simplesmente

<?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 necessário:

$datediff=abs($datediff);

Se você tiver os tempos em segundos (registro de data e hora do IE unix), poderá subtrair os tempos e dividir por 86400 (segundos por dia)

número de dias entre duas datas no 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 "; 

Você pode tentar o código abaixo:

$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 você deseja ecoar todos os dias entre a data de início e término, eu vim com isso:

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

A maneira mais fácil de encontrar a diferença de dias entre duas datas

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

Aqui está minha versão aprimorada, que mostra 1 ano (s) 2 meses (s) 25 dias (s) se o segundo parâmetro for passado.

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

usou o código acima muito simples. Obrigado.

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 esta função simples. Declarar função

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

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

e chame essa função assim onde quiser

<?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 você estiver usando o 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;

}

Tente usar o Carbon

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

Você também pode usar

\Carbon\Carbon::parse('')

para criar um objeto de data de carbono usando a sequência de carimbo de data / hora especificada.

Procurando todas as respostas, componho a função universal que funciona em todas as versões do 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;

Em geral, eu uso 'DateTime' para encontrar dias entre 2 datas. Mas se, por algum motivo, alguma configuração do servidor não tiver o 'DateTime' ativado, ele usará um cálculo simples (mas não seguro) com o 'strtotime ()'.