Calcola il numero di ore tra 2 date in PHP

Come si calcola la differenza tra due date in ore?

Per esempio:

day1=2006-04-12 12:30:00
day2=2006-04-14 11:30:00

In questo caso il risultato dovrebbe essere di 47 ore.

I più recenti PHP-versioni forniscono alcune nuove classi denominate DateTime, DateInterval, DateTimeZonee DatePeriod. La cosa interessante di questo corso è che considera diversi fusi orari, anni bisestili, secondi intercalari, ora estiva, ecc. E inoltre è molto facile da usare. Ecco cosa vuoi con l'aiuto di questi oggetti:

// Create two new DateTime-objects...
$date1 = new DateTime('2006-04-12T12:30:00');
$date2 = new DateTime('2006-04-14T11:30:00');

// The diff-methods returns a new DateInterval-object...
$diff = $date2->diff($date1);

// Call the format method on the DateInterval-object
echo $diff->format('%a Day and %h hours');

L'oggetto DateInterval, che viene restituito, fornisce anche altri metodi oltre a format. Se vuoi il risultato solo in ore, potresti fare qualcosa del genere:

$date1 = new DateTime('2006-04-12T12:30:00');
$date2 = new DateTime('2006-04-14T11:30:00');

$diff = $date2->diff($date1);

$hours = $diff->h;
$hours = $hours + ($diff->days*24);

echo $hours;

Ed ecco i link per la documentazione:

• DateTime-Class
• DateTimeZone-Class
• DateInterval-Class
• DatePeriod-Class

Tutte queste classi offrono anche un modo procedurale / funzionale per operare con le date. Quindi dai un'occhiata alla panoramica: http://php.net/manual/book.datetime.php

$t1 = strtotime( '2006-04-14 11:30:00' );
$t2 = strtotime( '2006-04-12 12:30:00' );
$diff = $t1 - $t2;
$hours = $diff / ( 60 * 60 );

Per fornire un altro metodo per DatePeriodquando si utilizza il fuso orario UTC o GMT .

Conta ore https://3v4l.org/Mu3HD

$start = new \DateTime('2006-04-12T12:30:00');
$end = new \DateTime('2006-04-14T11:30:00');

//determine what interval should be used - can change to weeks, months, etc
$interval = new \DateInterval('PT1H');

//create periods every hour between the two dates
$periods = new \DatePeriod($start, $interval, $end);

//count the number of objects within the periods
$hours = iterator_count($periods);
echo $hours . ' hours'; 

//difference between Unix Epoch
$diff = $end->getTimestamp() - $start->getTimestamp();
$hours = $diff / ( 60 * 60 );
echo $hours . ' hours (60 * 60)';

//difference between days
$diff = $end->diff($start);
$hours = $diff->h + ($diff->days * 24);
echo $hours . ' hours (days * 24)';

Risultato

47 hours (iterator_count)
47 hours (60 * 60)
47 hours (days * 24)

Conta le ore con l'ora legale https://3v4l.org/QBQUB

Si prega di notare che DatePeriodesclude un'ora per l'ora legale ma non aggiunge un'altra ora al termine dell'ora legale. Quindi il suo utilizzo è soggettivo al risultato e all'intervallo di date desiderati.

Vedi l'attuale segnalazione di bug

//set timezone to UTC to disregard daylight savings
date_default_timezone_set('America/New_York');

$interval = new \DateInterval('PT1H');

//DST starts Apr. 2nd 02:00 and moves to 03:00
$start = new \DateTime('2006-04-01T12:00:00');  
$end = new \DateTime('2006-04-02T12:00:00');

$periods = new \DatePeriod($start, $interval, $end);
$hours = iterator_count($periods);
echo $hours . ' hours';

//DST ends Oct. 29th 02:00 and moves to 01:00
$start = new \DateTime('2006-10-28T12:00:00');
$end = new \DateTime('2006-10-29T12:00:00'); 

$periods = new \DatePeriod($start, $interval, $end);
$hours = iterator_count($periods);
echo $hours . ' hours';

Risultato

#2006-04-01 12:00 EST to 2006-04-02 12:00 EDT
23 hours (iterator_count)
//23 hours (60 * 60)
//24 hours (days * 24)

#2006-10-28 12:00 EDT to 2006-10-29 12:00 EST
24 hours (iterator_count)
//25 hours (60 * 60)
//24 hours (days * 24)

#2006-01-01 12:00 EST to 2007-01-01 12:00 EST
8759 hours (iterator_count)
//8760 hours (60 * 60)
//8760 hours (days * 24)

//------

#2006-04-01 12:00 UTC to 2006-04-02 12:00 UTC
24 hours (iterator_count)
//24 hours (60 * 60)
//24 hours (days * 24)

#2006-10-28 12:00 UTC to 2006-10-29 12:00 UTC
24 hours (iterator_count)
//24 hours (60 * 60)
//24 hours (days * 24)

#2006-01-01 12:00 UTC to 2007-01-01 12:00 UTC
8760 hours (iterator_count)
//8760 hours (60 * 60)
//8760 hours (days * 24)

la tua risposta è:

round((strtotime($day2) - strtotime($day1))/(60*60))

Il modo più semplice per ottenere il numero corretto di ore tra due date (datetimes), anche durante i cambi di ora legale, è usare la differenza nei timestamp Unix. I timestamp Unix sono i secondi trascorsi dal 1970-01-01T00: 00: 00 UTC, ignorando i secondi intercalari (questo va bene perché probabilmente non hai bisogno di questa precisione, e perché è abbastanza difficile prendere in considerazione i secondi intercalari).

Il modo più flessibile per convertire una stringa datetime con informazioni opzionali sul fuso orario in un timestamp Unix consiste nel costruire un oggetto DateTime (facoltativamente con un DateTimeZone come secondo argomento nel costruttore) e quindi chiamare il relativo metodo getTimestamp .

$str1 = '2006-04-12 12:30:00'; 
$str2 = '2006-04-14 11:30:00';
$tz1 = new DateTimeZone('Pacific/Apia');
$tz2 = $tz1;
$d1 = new DateTime($str1, $tz1); // tz is optional,
$d2 = new DateTime($str2, $tz2); // and ignored if str contains tz offset
$delta_h = ($d2->getTimestamp() - $d1->getTimestamp()) / 3600;
if ($rounded_result) {
   $delta_h = round ($delta_h);
} else if ($truncated_result) {
   $delta_h = intval($delta_h);
}
echo "Δh: $delta_h\n";

//Calculate number of hours between pass and now
$dayinpass = "2013-06-23 05:09:12";
$today = time();
$dayinpass= strtotime($dayinpass);
echo round(abs($today-$dayinpass)/60/60);

$day1 = "2006-04-12 12:30:00"
$day1 = strtotime($day1);
$day2 = "2006-04-14 11:30:00"
$day2 = strtotime($day2);

$diffHours = round(($day2 - $day1) / 3600);

Immagino che la funzione strtotime () accetti questo formato di data.

<?
     $day1 = "2014-01-26 11:30:00";
     $day1 = strtotime($day1);
     $day2 = "2014-01-26 12:30:00";
     $day2 = strtotime($day2);

   $diffHours = round(($day2 - $day1) / 3600);

   echo $diffHours;

?>

Purtroppo la soluzione fornita da FaileN non funziona come dichiarato da Walter Tross .. i giorni potrebbero non essere 24 ore!

Mi piace usare gli oggetti PHP dove possibile e per un po 'più di flessibilità ho ideato la seguente funzione:

/**
 * @param DateTimeInterface $a
 * @param DateTimeInterface $b
 * @param bool              $absolute Should the interval be forced to be positive?
 * @param string            $cap The greatest time unit to allow
 *
 * @return DateInterval The difference as a time only interval
 */
function time_diff(DateTimeInterface $a, DateTimeInterface $b, $absolute=false, $cap='H'){

  // Get unix timestamps, note getTimeStamp() is limited
  $b_raw = intval($b->format("U"));
  $a_raw = intval($a->format("U"));

  // Initial Interval properties
  $h = 0;
  $m = 0;
  $invert = 0;

  // Is interval negative?
  if(!$absolute && $b_raw<$a_raw){
    $invert = 1;
  }

  // Working diff, reduced as larger time units are calculated
  $working = abs($b_raw-$a_raw);

  // If capped at hours, calc and remove hours, cap at minutes
  if($cap == 'H') {
    $h = intval($working/3600);
    $working -= $h * 3600;
    $cap = 'M';
  }

  // If capped at minutes, calc and remove minutes
  if($cap == 'M') {
    $m = intval($working/60);
    $working -= $m * 60;
  }

  // Seconds remain
  $s = $working;

  // Build interval and invert if necessary
  $interval = new DateInterval('PT'.$h.'H'.$m.'M'.$s.'S');
  $interval->invert=$invert;

  return $interval;
}

In questo modo viene date_diff()creato un DateTimeInterval, ma con l'unità più alta come ore anziché anni .. può essere formattato come al solito.

$interval = time_diff($date_a, $date_b);
echo $interval->format('%r%H'); // For hours (with sign)

NB L' ho usato al format('U')posto di getTimestamp()per via del commento nel manuale . Si noti inoltre che 64 bit è richiesto per le date post-epoch e pre-negative-epoch!

Questa funzione ti aiuta a calcolare anni e mesi esatti tra due date date $doj1e $doj. Restituisce l'esempio 4.3 significa 4 anni e 3 mesi.

<?php
    function cal_exp($doj1)
    {
        $doj1=strtotime($doj1);
        $doj=date("m/d/Y",$doj1); //till date or any given date

        $now=date("m/d/Y");
        //$b=strtotime($b1);
        //echo $c=$b1-$a2;
        //echo date("Y-m-d H:i:s",$c);
        $year=date("Y");
        //$chk_leap=is_leapyear($year);

        //$year_diff=365.25;

        $x=explode("/",$doj);
        $y1=explode("/",$now);

        $yy=$x[2];
        $mm=$x[0];
        $dd=$x[1];

        $yy1=$y1[2];
        $mm1=$y1[0];
        $dd1=$y1[1];
        $mn=0;
        $mn1=0;
        $ye=0;
        if($mm1>$mm)
        {
            $mn=$mm1-$mm;
            if($dd1<$dd)
            {
                $mn=$mn-1;
            }
            $ye=$yy1-$yy;
        }
        else if($mm1<$mm)
        {
            $mn=12-$mm;
            //$mn=$mn;

            if($mm!=1)
            {
                $mn1=$mm1-1;
            }

            $mn+=$mn1;
            if($dd1>$dd)
            {
                $mn+=1;
            }

            $yy=$yy+1;
            $ye=$yy1-$yy;
        }
        else
        {
            $ye=$yy1-$yy;
            $ye=$ye-1;

            $mn=12-1;

            if($dd1>$dd)
            {
                $ye+=1;
                $mn=0;
            }
        }

        $to=$ye." year and ".$mn." months";
        return $ye.".".$mn;

        /*return daysDiff($x[2],$x[0],$x[1]);
         $days=dateDiff("/",$now,$doj)/$year_diff;
        $days_exp=explode(".",$days);
        return $years_exp=$days; //number of years exp*/
    }
?>

Questo sta funzionando nel mio progetto. Penso, questo ti sarà utile.

Se la data è nel passato, invert sarà 1.
Se la data è nel futuro, invert sarà 0.

$defaultDate = date('Y-m-d');   
$datetime1   = new DateTime('2013-03-10');  
$datetime2   = new DateTime($defaultDate);  
$interval    = $datetime1->diff($datetime2);  
$days        = $interval->format('%a');
$invert      = $interval->invert;

Per passare un timestamp unix usa questa notazione

$now        = time();
$now        = new DateTime("@$now");

Anche il carbonio potrebbe essere un bel modo di procedere.

Dal loro sito web:

Una semplice estensione API PHP per DateTime. http://carbon.nesbot.com/

Esempio:

use Carbon\Carbon;

//...

$day1 = Carbon::createFromFormat('Y-m-d H:i:s', '2006-04-12 12:30:00');
$day2 = Carbon::createFromFormat('Y-m-d H:i:s', '2006-04-14 11:30:00');

echo $day1->diffInHours($day2); // 47

//...

Carbon estende la classe DateTime per ereditare metodi inclusi diff(). Si aggiunge piacevoli zuccheri come diffInHours, diffInMintutes, diffInSecondsecc

Innanzitutto, dovresti creare un oggetto intervallo da un intervallo di date. Solo dalla formulazione usata in questa frase, si possono facilmente identificare le astrazioni di base necessarie. C'è un intervallo come concetto e un paio di altri modi per implementarlo, includono quello già menzionato - da un intervallo di date. Quindi, un intervallo ha questo aspetto:

$interval =
    new FromRange(
        new FromISO8601('2017-02-14T14:27:39+00:00'),
        new FromISO8601('2017-03-14T14:27:39+00:00')
    );

FromISO8601ha la stessa semantica: è un oggetto datetime creato from iso8601-formatted string, da cui il nome.

Quando hai un intervallo, puoi formattarlo come preferisci. Se hai bisogno di un numero di ore intere, puoi farlo

(new TotalFullHours($interval))->value();

Se vuoi un totale di ore massime, ecco qui:

(new TotalCeiledHours($interval))->value();

Per ulteriori informazioni su questo approccio e alcuni esempi, controlla questa voce .

Oltre alla risposta molto utile di @ fyrye, questa è una soluzione alternativa per il bug menzionato ( questo ), che DatePeriod sottrae un'ora quando entra in estate, ma non aggiunge un'ora quando lascia l'estate (e quindi Europa / Berlino ha il suo 743 ore corrette ma ottobre ne ha 744 invece di 745):

Contando le ore di un mese (o qualsiasi periodo di tempo), considerando le transizioni dell'ora legale in entrambe le direzioni

function getMonthHours(string $year, string $month, \DateTimeZone $timezone): int
{
    // or whatever start and end \DateTimeInterface objects you like
    $start = new \DateTimeImmutable($year . '-' . $month . '-01 00:00:00', $timezone);
    $end = new \DateTimeImmutable((new \DateTimeImmutable($year . '-' . $month . '-01 23:59:59', $timezone))->format('Y-m-t H:i:s'), $timezone);
    
    // count the hours just utilizing \DatePeriod, \DateInterval and iterator_count, hell yeah!
    $hours = iterator_count(new \DatePeriod($start, new \DateInterval('PT1H'), $end));
    
    // find transitions and check, if there is one that leads to a positive offset
    // that isn't added by \DatePeriod
    // this is the workaround for https://bugs.php.net/bug.php?id=75685
    $transitions = $timezone->getTransitions((int)$start->format('U'), (int)$end->format('U'));
    if (2 === count($transitions) && $transitions[0]['offset'] - $transitions[1]['offset'] > 0) {
        $hours += (round(($transitions[0]['offset'] - $transitions[1]['offset'])/3600));
    }
    
    return $hours;
}

$myTimezoneWithDST = new \DateTimeZone('Europe/Berlin');
var_dump(getMonthHours('2020', '01', $myTimezoneWithDST)); // 744
var_dump(getMonthHours('2020', '03', $myTimezoneWithDST)); // 743
var_dump(getMonthHours('2020', '10', $myTimezoneWithDST)); // 745, finally!

$myTimezoneWithoutDST = new \DateTimeZone('UTC');
var_dump(getMonthHours('2020', '01', $myTimezoneWithoutDST)); // 744
var_dump(getMonthHours('2020', '03', $myTimezoneWithoutDST)); // 744
var_dump(getMonthHours('2020', '10', $myTimezoneWithoutDST)); // 744

PS Se controlli un periodo di tempo (più lungo), che porta a più di quelle due transizioni, la mia soluzione alternativa non toccherà le ore contate per ridurre il potenziale di effetti collaterali divertenti. In questi casi, è necessario implementare una soluzione più complicata. Si potrebbe iterare su tutte le transizioni trovate e confrontare la corrente con l'ultima e controllare se è una con DST true-> false.

$diff_min = ( strtotime( $day2 ) - strtotime( $day1 ) ) / 60 / 60;
$total_time  = $diff_min;

Puoi provare questo.