PHP में 2 तारीखों के बीच घंटों की संख्या की गणना करें

Question

मैं घंटों में दो तिथियों के बीच अंतर की गणना कैसे करूं?

उदाहरण के लिए:

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

इस मामले में परिणाम 47 घंटे होना चाहिए।

Comments

मेरी प्रारंभिक प्रतिक्रिया होगी, दोनों मानों को strftime()3600 तक के अंतर का उपयोग करते हुए टिकटों में बदल दें , लेकिन क्या यह हमेशा काम करेगा? धिक्कार है, डेलाइट सेविंग टाइम!

— पेकका

@Pekka: नहीं, यह हमेशा मुझे लगता है कि काम नहीं करेगा ... मेरे जवाब पर एक नज़र डालें। वहाँ मैंने एक विचार,

— टाइमज़ोन

@Pekka, यदि आप इसका उपयोग करते हैं तो strtotime()यह हमेशा काम करेगा, जब तक आप डिफ़ॉल्ट समयक्षेत्र का उपयोग करते हैं या स्पष्ट रूप से समय- सीमा ऑफसेट निर्दिष्ट करते हैं। डीएसटी को शाप देने का कोई कारण नहीं।

— वाल्टर ट्रॉस

Answer 1

नए पीएचपी-संस्करण कहा जाता है कुछ नए वर्गों प्रदान करते हैं DateTime, DateInterval, DateTimeZoneऔर DatePeriod। इस वर्गों के बारे में अच्छी बात यह है, कि यह विभिन्न टाइमज़ोन, लीप वर्ष, लीप सेकंड, ग्रीष्म, आदि को मानता है और इसके शीर्ष पर इसका उपयोग करना बहुत आसान है। यहां आप इस ऑब्जेक्ट की मदद से क्या चाहते हैं:

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

DateInterval- ऑब्जेक्ट, जो लौटाया गया है, की तुलना में अन्य तरीके भी प्रदान करता है format। यदि आप केवल घंटों में परिणाम चाहते हैं, तो आप इस तरह से कुछ कर सकते हैं:

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

और यहाँ प्रलेखन के लिए लिंक हैं:

• दिनांक समय-क्लास
• DateTimeZone-क्लास
• DateInterval-क्लास
• DatePeriod-क्लास

ये सभी कक्षाएं तिथियों के साथ संचालित करने के लिए एक प्रक्रियात्मक / कार्यात्मक तरीका भी प्रदान करती हैं। इसलिए अवलोकन करें: http://php.net/manual/book.datetime.php

Comments

+1 अच्छा काम! यह ठोस दिखता है और एक अच्छा अवलोकन है। यह ध्यान रखना महत्वपूर्ण है कि अलग-अलग डीएसटी नियमों के कारण गणना समय क्षेत्र के अनुसार भिन्न हो सकती है, इसलिए यह संभवतः क्षेत्र को परिभाषित करने और सर्वर सेटिंग्स पर भरोसा न करने का एक अच्छा विचार है।

— पेका

हां। इस ऑब्जेक्ट के साथ आप अलग-अलग टाइमज़ोन में तारीखों के बीच भी कैलक्लाइंट कर सकते हैं। $date1 = new DateTime('2006-04-12T12:30:00 Europe/Berlin');और$date2 = new DateTime('2006-04-14T11:30:00 America/New_York');

— फिडि

अगर कोई उसी मुद्दे पर चलता है जैसा कि मैंने अभी किया था जहाँ $diff->d0 के बराबर होता है (क्योंकि मैं दो तारीखों के बीच के घंटों की गणना करने की कोशिश कर रहा हूँ जो बिल्कुल 2 महीने अलग हैं): रनिंग var_dump($diff)ने मुझे एक और पैरामीटर दिखाया: ["days"]=>int(61)तो, मैंने उपयोग करना समाप्त कर दिया $hours = $diff->days * 24;, और यह आया 14 घंटे के "औसत" के करीब 2 30 दिन के महीने दिए गए, इसलिए यह 0. के परिणाम की तुलना में बहुत बेहतर लग रहा है (अनुमान लगा रहा हूं कि मेरा PHP संस्करण थोड़ा पुराना है ...)

— semmelbroesel

मेरा मतलब है कि दुनिया के कई हिस्सों में साल में एक दिन 23 घंटे और एक दिन 25 घंटे का होता है।

— वाल्टर ट्रॉस

@ कमाल मुरली, तो आपने इस जवाब के लिए बोनस देने का फैसला किया, जो गलत है? क्या आपने इस उत्तर के साथ जनवरी के पहले और जून के पहले दोपहर के बीच घंटों की संख्या की गणना करने की कोशिश की है, किसी भी समय में डीएसटी (दिन के समय की बचत) है? आपको एक परिणाम मिलेगा, जबकि असली परिणाम विषम है।

— वाल्टर ट्रॉस

Answer 2

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

Comments

क्यों नहीं $diff / 3600?

— एलेक्स जी

@ एलेक्स जी यह सिर्फ एक स्टाइल की चीज है। समान आउटपुट, लेकिन प्रोग्रामर आमतौर पर गुणा का उपयोग तब करते हैं जब यह समय पर आता है

— उपयोगकर्ता

मैं आपको पसंद करने के लिए सुझाव देता हूं: गोल (($ t1 - $ 22) / 3600); सही समय पाने के लिए गोल का उपयोग करें

— शिव सिंह

Answer 3

यूटीसी या जीएमटी टाइमज़ोन DatePeriodका उपयोग करते समय एक और विधि प्रदान करने के लिए ।

गणना का समय 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)';

परिणाम

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

---

डेलाइट सेविंग के साथ गणना घंटे https://3v4l.org/QBQUB

कृपया सलाह दी जाए कि DatePeriodडीएसटी के लिए एक घंटे को छोड़ दें, लेकिन डीएसटी समाप्त होने पर एक और घंटा न जोड़ें। तो इसका उपयोग आपके इच्छित परिणाम और दिनांक सीमा के अधीन है।

वर्तमान बग रिपोर्ट देखें

//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';

परिणाम

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

Comments

किसी के रूप में भ्रमित के रूप में मैं DateInterval निर्माता पैरामीटर को देखने में था, प्रारूप एक आईएसओ 8601 अवधि है

— TheKarateKid

एक और नोट यह है कि DateIntervalआईएसओ 8601 विनिर्देशन में भिन्नात्मक मूल्यों को स्वीकार नहीं किया गया है। तो P1.2YPHP में एक वैध अवधि नहीं है।

— fyrye

नोट: iterator_count केवल सकारात्मक परिणाम लौटाएगा। यदि पहली तारीख अधिक है, तो दूसरा परिणाम, अंतर परिणाम 0. होगा

— विषयवस्तु

@SubjectDelta समस्या से संबंधित नहीं है iterator_count, यह DatePeriodउस तारीख को उत्पन्न करने में सक्षम नहीं होने के कारण है जब प्रारंभ दिनांक अंतिम तिथि से भविष्य में है। देखें: 3v4l.org/Ypsp1 एक नकारात्मक तिथि का उपयोग करने के लिए, आपको एक नकारात्मक अंतराल निर्दिष्ट करने की आवश्यकता है, DateInterval::createFromDateString('-1 hour');जिसमें अंतिम तिथि से पहले की तारीख है।

— fyrye

@SubjectDelta यह एक और अति सूक्ष्म अंतर है DatePeriod, क्योंकि डिफ़ॉल्ट रूप से इसमें निर्दिष्ट अवधियों के बीच प्रारंभ तिथि शामिल होगी जब तक कि वे प्रारंभ तिथि से कम या बराबर नहीं होती हैं। वास्तव में आप php को दो तिथियों के बीच 1 घंटे की अवधि बनाने के लिए कह रहे हैं, 1 सेकंड के भीतर। आपको अपनी दिनांक ऑब्जेक्ट से मिनट और सेकंड निकालने की आवश्यकता होगी, क्योंकि वे गणना में प्रासंगिक नहीं हैं, उपयोग करते हुए DateTime::setTime(date->format('H'), 0)। 3v4l.org/K7uss इस तरह यदि आप 1 सेकंड की सीमा से अधिक हैं, तो दूसरी तारीख नहीं बनाई जाती है।

— fyrye

Answer 4

आपका जवाब है:

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

Comments

अगर 2 घंटे और 30 मिनट के बीच क्या हो? आपके उत्तर का परिणाम 3 घंटे होगा। मुझे लगता है कि फर्श का उपयोग करना बेहतर होगा ताकि 2 घंटे का उत्पादन हो। वास्तव में स्थिति पर निर्भर करता है।

— कपितिन विटबार्ड

Answer 5

दो तिथियों (डेटाइम) के बीच घंटों की सही संख्या प्राप्त करने का सबसे आसान तरीका, यहां तक ​​कि दिन के उजाले की बचत के समय में परिवर्तन, यूनिक्स टाइमस्टैम्प में अंतर का उपयोग करना है। यूनिक्स टाइमस्टैम्प्स 1970-01-01T00: 00: 00 UTC के बाद से लीप सेकंड को अनदेखा कर रहे हैं (यह ठीक है क्योंकि आपको शायद इस परिशुद्धता की आवश्यकता नहीं है, और क्योंकि यह लीप सेकंड को ध्यान में रखना काफी मुश्किल है)।

एक यूनिक्स टाइमस्टैम्प में वैकल्पिक समय क्षेत्र जानकारी के साथ एक datetime स्ट्रिंग परिवर्तित करने के लिए सबसे सुविधाजनक ढंग से एक का निर्माण करने की है दिनांक समय (वैकल्पिक रूप से एक के साथ वस्तु DateTimeZone निर्माता में एक दूसरे तर्क के रूप में), और फिर अपने फोन 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";

Comments

में एक टिप्पणी से मैनुअल यह है कि प्रतीत होता है, पूर्व युग तिथियों के साथ संगतता के लिए, format("U")बेहतर हैgetTimestamp()

— अर्थ

@ लेकिन, मुझे नहीं पता कि ऐसा कब हुआ था, लेकिन मेरे PHP 5.5.9 में यह सच नहीं है। getTimestamp()अब ठीक वैसा ही मूल्य देता है जैसा कि format("U")। पूर्व एक पूर्णांक है, हालांकि, जबकि बाद वाला एक स्ट्रिंग है (यहां कम कुशल है)।

— वाल्टर ट्रॉस

कूल, शायद यह एक पुराने संस्करण में सच था .. हाँ एक पूर्णांक क्लीनर होगा, इसलिए मैं पसंद करूंगा getTimestamp()अगर मुझे यकीन हो।

— आर्थर

Answer 6

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

Answer 7

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

मुझे लगता है कि strtotime () फ़ंक्शन इस दिनांक प्रारूप को स्वीकार करता है।

Answer 8

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

?>

Comments

यह उत्तर प्रपत्र 2010 की एक प्रति भी है।

— डैनियल डब्ल्यू।

Answer 9

दुर्भाग्य से FaileN द्वारा प्रदान किया गया समाधान वाल्टर ट्रॉस द्वारा कहा गया काम नहीं करता है .. दिन 24 घंटे नहीं हो सकते हैं!

मैं PHP ऑब्जेक्ट्स का उपयोग करना पसंद करता हूं, जहां संभव है और थोड़े अधिक लचीलेपन के लिए मैं निम्नलिखित फ़ंक्शन के साथ आया हूं:

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

इस तरह date_diff()एक बनाता है DateTimeInterval, लेकिन साल के बजाय घंटे के रूप में उच्चतम इकाई के साथ .. यह हमेशा की तरह स्वरूपित किया जा सकता है।

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

मैनुअल में टिप्पणी format('U')के getTimestamp()कारण एनबी I का उपयोग किया गया है । यह भी ध्यान दें कि युग-पूर्व और पूर्व-नकारात्मक-युगांतर तिथियों के लिए 64-बिट आवश्यक है!

Answer 10

यह फ़ंक्शन आपको दो दी गई तारीखों के बीच सटीक वर्षों और महीनों की गणना करने में मदद करता है, $doj1और $doj। यह उदाहरण देता है 4.3 का मतलब 4 साल और 3 महीने है।

<?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*/
    }
?>

Comments

सुझाया गया संपादन बहुत छोटा है, लेकिन सुझाए गए संपादन को <phpबदलने <?phpया अनुमोदित करने की आवश्यकता है , जो बग को एक साथ हटा देता है।

— ऐशसेन

Answer 11

यह मेरे प्रोजेक्ट में काम कर रहा है। मुझे लगता है, यह आपके लिए मददगार होगा।

यदि तिथि पूर्व में है तो उल्टा होगा।
यदि तिथि भविष्य में है तो उल्टा 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;

Answer 12

यूनिक्स टाइमस्टैम्प पास करने के लिए इस अंकन का उपयोग करें

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

Comments

नोट दिनांक समय निर्माण में +0:00उपयोग @करते समय टाइमज़ोन पास और आउटपुट होगा । DateTime::modify()विधि का उपयोग करते समय टाइमस्टैम्प को पास किया जाएगा +0:00और वर्तमान समय क्षेत्र को आउटपुट करेगा। वैकल्पिक रूप से $date = new DateTime(); $date->setTimestamp($unix_timestamp);देखें: 3v4l.org/BoAWI

— fyrye

Answer 13

कार्बन भी जाने का एक अच्छा तरीका हो सकता है।

उनकी वेबसाइट से:

DateTime के लिए एक सरल PHP API एक्सटेंशन। http://carbon.nesbot.com/

उदाहरण:

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

//...

कार्बन डेटाईट क्लास को विरासत में मिली विधियों सहित बढ़ाता है diff()। ऐसा लगता है कि अच्छा शक्कर कहते हैं diffInHours, diffInMintutes, diffInSecondsआदि

Answer 14

सबसे पहले, आपको तिथियों की एक श्रृंखला से एक अंतराल ऑब्जेक्ट बनाना चाहिए। इस वाक्य में अकेले शब्द का उपयोग करके, कोई भी आसानी से आवश्यक मूलभूत सार की पहचान कर सकता है। एक अवधारणा के रूप में एक अंतराल है, और इसे लागू करने के लिए और अधिक तरीकों के एक जोड़े में, पहले से ही उल्लेख किया गया है - तिथियों की एक श्रृंखला से। इस प्रकार, एक अंतराल ऐसा दिखता है:

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

FromISO8601एक ही शब्दार्थ है: यह एक डेटाइम ऑब्जेक्ट बनाया गया है from iso8601-formatted string, इसलिए नाम।

जब आपके पास एक अंतराल होता है, तो आप इसे अपनी पसंद के अनुसार प्रारूपित कर सकते हैं। यदि आपको पूरे घंटे की संख्या की आवश्यकता है, तो आप कर सकते हैं

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

अगर आपको कुल घंटे चाहिए, तो आप यहाँ जाएँ:

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

इस दृष्टिकोण और कुछ उदाहरणों के बारे में अधिक जानने के लिए, इस प्रविष्टि को देखें ।

Answer 15

के अलावा @ fyrye बहुत मददगार जवाब यह उल्लेख बग (के लिए एक okayish समाधान नहीं है यह एक ), कि DatePeriod एक घंटे substracts जब गर्मियों में प्रवेश, लेकिन जब गर्मियों छोड़ने (और इस प्रकार यूरोप / बर्लिन के मार्च अपनी है एक घंटे नहीं जोड़ता है सही 743 घंटे लेकिन अक्टूबर में 745 घंटे के बजाय 744 है):

एक महीने (या किसी भी समय) के घंटे की गिनती, दोनों दिशाओं में डीएसटी-बदलाव पर विचार करना

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

पुनश्च यदि आप एक (अधिक) समय-समय पर जांच करते हैं, जो उन दो संक्रमणों से अधिक की ओर जाता है, तो मेरा वर्कअराउंड फनी साइड इफेक्ट्स की संभावना को कम करने के लिए गिने हुए घंटों को नहीं छूएगा। ऐसे मामलों में, अधिक जटिल समाधान को लागू किया जाना चाहिए। सभी पाए गए संक्रमणों पर एक पुनरावृत्ति कर सकता है और अंतिम के साथ वर्तमान की तुलना कर सकता है और यह जांच सकता है कि क्या यह डीएसटी के साथ सही है-> गलत।

Answer 16

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

आप यह एक कोशिश कर सकते हैं।