¿Qué se puede usar para DateTime:: diff() para PHP 5.2?

php-5.2

Question

¿Hay alguna función equivalente a DateTime :: diff () en PHP 5.2?

Mi servidor local es PHP 5.3 y usa DateTime :: diff (). luego descubrí que mi sitio en vivo utiliza PHP 5.2 y da un error.

Fatal error: Call to undefined method DateTime::diff() in /var/www/some/other/dir/web/daikon/modules/projects/views/admin/log/admin_log_list.php on line 40

El código PHP:

 foreach ($logs as $key => $list){
 ...
 // show date in European way dd-mm-yyyy not in MySQL way yyyy-mm-dd
    $newdate =new DateTime($list[''date'']) ;
    echo "<td class=/"left/" width=/"8%/">".$newdate->format(''d-m-Y'')."</td>/n";
    $starttime = new DateTime($list[''start_time'']);
    echo "<td width=/"7%/">".date_format($starttime, ''H:i'')."</td>/n";
    $finishtime = new DateTime($list[''finish_time'']);
    echo "<td width=/"8%/">".date_format($finishtime, ''H:i'')."</td>/n";
    $timediff = 0;
    $interval = $starttime->diff($finishtime);
    $hours   = $interval->format(''%h'');
    $minutes = $interval->format(''%i'');
    $timediff = $hours * 60 + $minutes;

Answer 1

Aquí está la mejor solución para tu pregunta.

<?php

/* Find difference between two dates in days. PHP 5.2.x.  */

$d1 = date(''Y-m-d'', strtotime(''2013-06-13''));
$d2 = date("Y-m-d");
echo diff($d1, $d2);

function diff($date1, $date2) {
    $diff = abs(strtotime($date2) - strtotime($date1));
    $years = floor($diff / (365*60*60*24));
    $months = floor(($diff - $years * 365*60*60*24) / (30*60*60*24));
    $days = floor(($diff - $years * 365*60*60*24 - $months*30*60*60*24) / (60*60*24));
    return $days;
}
?>

Answer 2

Estaba tratando de mejorar la respuesta de Christopher Pickslay.

Hice esta función que devuelve y objeta con la mayoría de las propiedades del objeto DateInterval original.

No hay propiedad de "días", porque parece ser un error en mi servidor de prueba (siempre devuelve 6015).

Además, supongo que cada mes tiene 30 días, lo que definitivamente no es preciso, pero puede ayudar.

function dateTimeDiff($date1, $date2) {

    $alt_diff = new stdClass();
    $alt_diff->y =  floor(abs($date1->format(''U'') - $date2->format(''U'')) / (60*60*24*365));
    $alt_diff->m =  floor((floor(abs($date1->format(''U'') - $date2->format(''U'')) / (60*60*24)) - ($alt_diff->y * 365))/30);
    $alt_diff->d =  floor(floor(abs($date1->format(''U'') - $date2->format(''U'')) / (60*60*24)) - ($alt_diff->y * 365) - ($alt_diff->m * 30));
    $alt_diff->h =  floor( floor(abs($date1->format(''U'') - $date2->format(''U'')) / (60*60)) - ($alt_diff->y * 365*24) - ($alt_diff->m * 30 * 24 )  - ($alt_diff->d * 24) );
    $alt_diff->i = floor( floor(abs($date1->format(''U'') - $date2->format(''U'')) / (60)) - ($alt_diff->y * 365*24*60) - ($alt_diff->m * 30 * 24 *60)  - ($alt_diff->d * 24 * 60) -  ($alt_diff->h * 60) );
    $alt_diff->s =  floor( floor(abs($date1->format(''U'') - $date2->format(''U''))) - ($alt_diff->y * 365*24*60*60) - ($alt_diff->m * 30 * 24 *60*60)  - ($alt_diff->d * 24 * 60*60) -  ($alt_diff->h * 60*60) -  ($alt_diff->i * 60) );
    $alt_diff->invert =  (($date1->format(''U'') - $date2->format(''U'')) > 0)? 0 : 1 ;

    return $alt_diff;
}    

Answer 3

La respuesta de Spudley no funciona para mí: restar cualquier DateTime de otro da 0 en mi sistema.

Pude hacer que funcionase usando el formato DateTime :: con el especificador ''U'' (segundos desde Unix epoch):

$start = new DateTime(''2010-10-12'');
$end = new DateTime();
$days = round(($end->format(''U'') - $start->format(''U'')) / (60*60*24));

Esto funciona tanto en mi sistema de desarrollo (5.3.4) como en mi sistema de despliegue (5.2.11).

Answer 4

Lea las notas contrib en la página PHP date_diff http://us3.php.net/manual/en/function.date-diff.php

Answer 5

PHP tiene métodos para trabajar con marcas de tiempo Unix.

Como han observado otros, al trabajar con segundos desde la fecha de Unix, es fácil calcular los tiempos.

El strtotime de PHP () convierte una fecha en una marca de tiempo:

$diff = round((strtotime($list[''start'']) - strtotime($list[''finish''])) / 86400);

Si desea calcular hasta la hora actual, time () proporciona la marca de tiempo de "ahora":

$diff = round((time() - strtotime($list[''date''])) / 86400);

86400 es la cantidad de segundos en un día.
Si desea convertir a años, use 31557000, que es casi exactamente 365.24219 * 86400.

Una ventaja adicional aquí es que strtotime puede tomar la fecha de entrada en casi cualquier formato legible por humanos, por lo que es muy fácil trabajar dentro del código.

Answer 6

Sí, es molesto que la característica no haya llegado a PHP5.2.

¿Asumiré que no puedes actualizar a 5.3? Deberías mirarlo; hay muy pocas razones para no actualizar; pero supongo que no puedes por la razón que sea.

Primer consejo: si solo necesitas una diferencia de menos de 24 horas, puedes simplemente restar las dos $time_diff = date(''H:i:s'',$subtracted_value); tiempo, y hacer $time_diff = date(''H:i:s'',$subtracted_value);

Si está haciendo diffs de más de 24 horas, pero está bien simplemente devolviendo el número de días junto con la diferencia de tiempo, puede ampliar la técnica anterior haciendo un cálculo de módulo sobre el valor sustraído, contra el número de segundos en un día (es decir, 24 * 60 * 60, que es 86400)

$subtracted_value = $date1 - $date2;
$days_diff = $subtracted_value % 86400;
$time_diff = date(''H:i:s'',$subtracted_value);

Si necesita semanas, puede hacer $days_diff % 7 .

Desafortunadamente, la técnica manual se descompone después de semanas, porque los meses y los años son de duración variable (técnicamente los días también lo son, con horario de verano, pero probablemente pueda ignorar eso, especialmente porque solo va a estar una hora fuera, en más), pero espero que sea lo suficientemente bueno como para comenzar.

Answer 7

Solo necesitaba eso (desafortunadamente) para un plugin de WordPress. Esto uso la función en 2 veces:

1. En mi clase llamando -> diff () (mi clase extiende DateTime , así que $ this es la referencia DateTime )

   function diff ($secondDate){
       $firstDateTimeStamp = $this->format("U");
       $secondDateTimeStamp = $secondDate->format("U");
       $rv = ($secondDateTimeStamp - $firstDateTimeStamp);
       $di = new DateInterval($rv);
       return $di;
   }

2. Luego recreé una clase de DateInterval falsa (porque DateInterval solo es válida en PHP> = 5.3) de la siguiente manera:

   Class DateInterval {
       /* Properties */
       public $y = 0;
       public $m = 0;
       public $d = 0;
       public $h = 0;
       public $i = 0;
       public $s = 0;
   
       /* Methods */
       public function __construct ( $time_to_convert /** in seconds */) {
           $FULL_YEAR = 60*60*24*365.25;
           $FULL_MONTH = 60*60*24*(365.25/12);
           $FULL_DAY = 60*60*24;
           $FULL_HOUR = 60*60;
           $FULL_MINUTE = 60;
           $FULL_SECOND = 1;
   
   //        $time_to_convert = 176559;
           $seconds = 0;
           $minutes = 0;
           $hours = 0;
           $days = 0;
           $months = 0;
           $years = 0;
   
           while($time_to_convert >= $FULL_YEAR) {
               $years ++;
               $time_to_convert = $time_to_convert - $FULL_YEAR;
           }
   
           while($time_to_convert >= $FULL_MONTH) {
               $months ++;
               $time_to_convert = $time_to_convert - $FULL_MONTH;
           }
   
           while($time_to_convert >= $FULL_DAY) {
               $days ++;
               $time_to_convert = $time_to_convert - $FULL_DAY;
           }
   
           while($time_to_convert >= $FULL_HOUR) {
               $hours++;
               $time_to_convert = $time_to_convert - $FULL_HOUR;
           }
   
           while($time_to_convert >= $FULL_MINUTE) {
               $minutes++;
               $time_to_convert = $time_to_convert - $FULL_MINUTE;
           }
   
           $seconds = $time_to_convert; // remaining seconds
           $this->y = $years;
           $this->m = $months;
           $this->d = $days;
           $this->h = $hours;
           $this->i = $minutes;
           $this->s = $seconds;
       }
   }

Espero que ayude a alguien.

Answer 8

Spudley estaba cerca, pero necesitas usar gmdate, no date.

Entonces esto funciona por 24 horas o menos (si es un valor positivo al menos):

$difference = $date2->format(''U'') - $date1->format(''U'');
$time_diff = gmdate(''H:i:s'',$difference);

Answer 9

Tenga en cuenta que si su objeto DateTime se creó a partir de una cadena de fecha sin información de zona horaria (como en ''2012-01-01 05:00:00'' como desde mysql), entonces la configuración de la zona horaria más tarde con objetos DateTimeZone a través de setTimeZone () lo hace no cambie la marca de tiempo interna de los objetos DateTime.

$localtime = new DateTime(''2012-01-01 08:00:00+02:00''); // Europe/Copenhagen (+ daylight savings)
$localtime->setTimezone(new DateTimeZone(''UTC'')); // convert local time to utc

$utctime = new DateTime(''2012-01-01 06:00:00''); // timezone assumed utc, but is in fact unknown
$utctime->setTimezone(new DateTimeZone(''UTC'')); // trying to rectify missing timezone which fails, because the internal timestamp isn''t modified, although any other format than ''U'' may indicate so
#$utctime = new DateTime(''2012-01-01 06:00:00+00:00''); // timezone stated, this works

$diff = intval($localtime->format(''U'')) - intval($utctime->format(''U''));
echo $diff; // expecting zero

Answer 10

Yo uso esto, parece funcionar bien, obviamente puedes agregar un segundo parámetro para hacerlo más flexible:

function GetDateDiffFromNow($originalDate) 
{
    $unixOriginalDate = strtotime($originalDate);
    $unixNowDate = strtotime(''now'');
    $difference = $unixNowDate - $unixOriginalDate ;
    $days = (int)($difference / 86400);
    $hours = (int)($difference / 3600);
    $minutes = (int)($difference / 60);
    $seconds = $difference;

    // now do what you want with this now and return ...
}