¿Cómo encontrar el número de días entre dos fechas 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));

Si está utilizando PHP 5.3 >, esta es, con mucho, la forma más precisa de calcular la diferencia:

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

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

Desde la versión 5.3 de PHP en adelante, se han agregado nuevas funciones de fecha / hora para obtener la diferencia:

$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 de la siguiente manera:

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 eso ayude !

Convierta sus fechas en marcas de tiempo unix, luego reste una de la otra Eso le dará la diferencia en segundos, que divide por 86400 (cantidad de segundos en un día) para obtener una cantidad aproximada de días en ese rango.

Si sus fechas están en formato 25.1.2010, 01/25/2010o 2010-01-25puede usar la strtotimefunción:

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

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

Usando ceilrondas la cantidad de días hasta el próximo día completo. Use flooren su lugar si desea obtener la cantidad de días completos entre esas dos fechas.

Si sus fechas ya están en formato de marca de tiempo Unix, puede omitir la conversión y simplemente hacer la $days_betweenparte. Para formatos de fecha más exóticos, es posible que deba realizar un análisis personalizado para hacerlo bien.

TL; DR qué no usar las marcas de tiempo UNIX. No utilicetime() . Si lo hace, prepárese si su 98.0825% de confiabilidad le falla. Use DateTime (o Carbon).

La respuesta correcta es la dada por Saksham Gupta (otras respuestas también son correctas):

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

O procesalmente como una línea:

/**
 * 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 una advertencia: el '% a' parece indicar el número absoluto de días. Si lo desea como un entero con signo, es decir, negativo cuando la segunda fecha es anterior a la primera, debe usar el prefijo '% r' (es decir format('%r%a')).

Si realmente debe usar las marcas de tiempo UNIX, configure la zona horaria en GMT para evitar la mayoría de las trampas que se detallan a continuación.

Respuesta larga: por qué dividir entre 24 * 60 * 60 (también conocido como 86400) no es seguro

La mayoría de las respuestas que usan marcas de tiempo UNIX (y 86400 para convertir eso en días) hacen dos suposiciones que, juntas, pueden conducir a escenarios con resultados incorrectos y errores sutiles que pueden ser difíciles de rastrear, y pueden surgir incluso días, semanas o meses después Un despliegue exitoso. No es que la solución no funcione, funciona. Hoy. Pero podría dejar de funcionar mañana.

El primer error no es considerar que, cuando se le pregunta, "¿Cuántos días pasaron desde ayer?", Una computadora podría responder verdaderamente a cero si entre el presente y el instante indicado por "ayer" ha pasado menos de un día entero .

Por lo general, al convertir un "día" en una marca de tiempo UNIX, lo que se obtiene es la marca de tiempo de la medianoche de ese día en particular.

Entonces, entre la medianoche del 1 de octubre y el 15 de octubre, han transcurrido quince días. Pero entre las 13:00 del 1 de octubre y las 14:55 del 15 de octubre, han transcurrido quince días menos 5 minutos , y la mayoría de las soluciones que usan floor()o realizan conversiones enteras implícitas informarán un día menos de lo esperado .

Entonces, "¿cuántos días hace Ymd H: i: s"? dará la respuesta incorrecta .

El segundo error es equiparar un día a 86400 segundos. Esto es casi siempre cierto: sucede con la frecuencia suficiente para pasar por alto los momentos en que no lo hace. Pero la distancia en segundos entre dos medianoches consecutivas seguramente no es de 86400 al menos dos veces al año cuando entra en juego el horario de verano. La comparación de dos fechas a través de un límite DST arrojará la respuesta incorrecta.

Entonces, incluso si usa el "truco" de forzar todas las marcas de fecha y hora a una hora fija, digamos medianoche (esto también se hace implícitamente en varios idiomas y marcos cuando solo especifica día-mes-año y no también hora-minuto-segundo; lo mismo sucede con el tipo DATE en bases de datos como MySQL), la fórmula ampliamente utilizada

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

o

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

regresará, digamos, 17 cuando DATE1 y DATE2 están en el mismo segmento DST del año; pero puede devolver 17.042, y peor aún, 16.958. El uso de floor () o cualquier truncamiento implícito a entero convertirá lo que debería haber sido un 17 en 16. En otras circunstancias, expresiones como "$ días> 17" volverán truepara 17.042 incluso si esto indica que el día transcurrido cuenta es 18.

Y las cosas se ponen aún más feas, ya que dicho código no es portátil en todas las plataformas, porque algunos de ellos pueden aplicar segundos de salto y otros no . En las plataformas que lo hacen , la diferencia entre dos fechas no será 86400 sino 86401, o quizás 86399. Por lo tanto, el código que funcionó en mayo y que realmente pasó todas las pruebas se romperá el próximo junio cuando 12.99999 días se consideran 12 días en lugar de 13. Dos fechas que funcionó en 2015 no funcionará en 2017, las mismas fechas, y ninguno de los dos años es bisiesto. Pero entre 2018-03-01 y 2017-03-01, en esas plataformas que se preocupan, habrán pasado 366 días en lugar de 365, haciendo de 2018 un año bisiesto (que no lo es).

Entonces, si realmente desea utilizar las marcas de tiempo UNIX:

• use la round()función sabiamente, no floor().

• como alternativa, no calcule las diferencias entre D1-M1-YYY1 y D2-M2-YYY2. Esas fechas se considerarán realmente como D1-M1-AAA1 00:00:00 y D2-M2-AAA2 00:00:00. En cambio, convierta entre D1-M1-AAA1 22:30:00 y D2-M2-AAA2 04:30:00. Usted siempre conseguir un resto de unos veinte horas. Esto puede convertirse en veintiuna horas o diecinueve, y tal vez dieciocho horas, cincuenta y nueve minutos treinta y seis segundos. No importa. Es un gran margen que permanecerá allí y seguirá siendo positivo en el futuro previsible. Ahora puedes truncarlo con floor()seguridad.

Sin embargo, la solución correcta , para evitar constantes mágicas, redondear errores y una deuda de mantenimiento, es

• usar una biblioteca de tiempo (fecha y hora, carbono, lo que sea); no ruedes el tuyo

• escriba casos de prueba exhaustivos utilizando elecciones de fechas realmente malvadas: a través de los límites del horario de verano, a través de los años bisiestos, a través de los segundos bisiestos, etc., así como las fechas comunes. Idealmente (¡las llamadas a datetime son rápidas !) Generan cuatro años enteros (y un día) de fechas reuniéndolos a partir de cadenas, secuencialmente, y aseguran que la diferencia entre el primer día y el día de prueba aumente de manera constante en uno. Esto asegurará que si algo cambia en las rutinas de bajo nivel y las correcciones de segundos de salto intenten causar estragos, al menos lo sabrán .

• ejecute esas pruebas regularmente junto con el resto del conjunto de pruebas. Son cuestión de milisegundos y pueden ahorrarle literalmente horas de rascarse la cabeza.

Cualquiera sea su solución, ¡pruébelo!

La funcdiffsiguiente función implementa una de las soluciones (como sucede, la aceptada) en un escenario del 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";

El resultado es,

This function failed 280 of its 14603 tests

Horror Story: el costo de "ahorrar tiempo"

Esto realmente sucedió hace unos meses. Un ingenioso programador decidió guardar varios microsegundos de un cálculo que tomó aproximadamente treinta segundos como máximo, conectando el infame código "(MidnightOfDateB-MidnightOfDateA) / 86400" en varios lugares. Era una optimización tan obvia que ni siquiera la documentó, y la optimización pasó las pruebas de integración y estuvo al acecho en el código durante varios meses, todo inadvertido.

Esto sucedió en un programa que calcula los salarios de varios vendedores de mayor venta, el menor de los cuales tiene mucho más peso que un humilde equipo de programadores de cinco personas en conjunto. Un día, hace unos meses, por razones que importan poco, se produjo el error, y algunos de esos tipos se quedaron cortos un día entero de comisiones gordas. Definitivamente no les hizo gracia.

Infinitamente peor, perdieron la (ya muy poca) fe que tenían en el programa que no estaba diseñado para engañarlos subrepticiamente, y pretendieron, y obtuvieron , una revisión completa y detallada del código con casos de prueba ejecutados y comentados en términos simples (más mucho de tratamiento con alfombra roja en las siguientes semanas).

Qué puedo decir: en el lado positivo, nos deshicimos de una gran cantidad de deudas técnicas y pudimos reescribir y refactorizar varias piezas de un desorden de espagueti que se remonta a una infestación de COBOL en los años 90. El programa, sin duda, funciona mejor ahora, y hay mucha más información de depuración para concentrarse rápidamente cuando algo parece sospechoso. Calculo que solo esto último ahorrará quizás uno o dos días-hombre por mes en el futuro previsible.

En el lado negativo, todo el alboroto le costó a la compañía unos 200,000 € por adelantado, más cara, más indudablemente algo de poder de negociación (y, por lo tanto, aún más dinero).

El responsable de la "optimización" había cambiado de trabajo hace un año, antes del desastre, pero aún se hablaba de demandarlo por daños. Y no funcionó bien con los niveles superiores que era "la culpa del último tipo", parecía una trampa para nosotros aclarar el asunto, y al final, todavía estamos en la caseta del perro. y uno del equipo planea renunciar.

Noventa y nueve de cada cien, el "hack 86400" funcionará perfectamente. (Por ejemplo, en PHP, strtotime()ignorará el horario de verano e informará que entre la medianoche del último sábado de octubre y el lunes siguiente, han pasado exactamente 2 * 24 * 60 * 60 segundos, incluso si eso simplemente no es cierto ... y dos errores harán felizmente uno correcto).

Esto, damas y caballeros, fue una instancia en la que no fue así. Al igual que con las bolsas de aire y los cinturones de seguridad, tal vez nunca necesite realmente la complejidad (y facilidad de uso) de DateTimeo Carbon. Pero el día en que podría (o el día en que tendrá que demostrar que pensó en esto) vendrá como ladrón en la noche. Estar 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');

• Ver más en: 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 de procedimiento:

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

Usé esto :)

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

Ahora funciona

Bueno, la respuesta seleccionada no es la más correcta porque fallará fuera de UTC. Dependiendo de la zona horaria ( lista ) podría haber ajustes de tiempo creando días "sin" 24 horas, y esto hará que el cálculo (60 * 60 * 24) falle.

Aquí hay un ejemplo de ello:

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

Entonces, la solución correcta será usar 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 la diferencia entre dos fechas:

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

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

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

Salida: +272 días

La función date_diff () devuelve la diferencia entre dos objetos DateTime.

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

Estoy usando Carbon en mis proyectos de compositor para este y otros propósitos similares.

Sería tan fácil como esto:

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

Puedes encontrar fechas simplemente por

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

y, si es necesario:

$datediff=abs($datediff);

Si tiene los tiempos en segundos (marca de tiempo de IE Unix), simplemente puede restar los tiempos y dividirlos entre 86400 (segundos por día)

Número de días entre dos fechas en 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 "; 

Puedes probar el siguiente código:

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

Si desea repetir todos los días entre la fecha de inicio y finalización, se me ocurrió esto:

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

La forma más fácil de encontrar la diferencia de días entre dos fechas

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

Aquí está mi versión mejorada que muestra 1 año (s) 2 mes (es) 25 día (s) si se pasa el segundo parámetro.

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

Utilicé el código anterior muy simple. Gracias.

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 simple función. Declarar función

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

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

y llama a esta función así donde quieras

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

Si estás 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;

}

Intenta usar carbono

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

También puedes usar

\Carbon\Carbon::parse('')

para crear un objeto de fecha de carbono utilizando una cadena de marca de tiempo dada.

Buscando todas las respuestas, compongo la función universal que funciona en todas las versiones de 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;

En general, uso 'DateTime' para encontrar días entre 2 fechas. Pero si por alguna razón, alguna configuración del servidor no tiene habilitado 'DateTime', usará un cálculo simple (pero no seguro) con 'strtotime ()'.