PHP का उपयोग करके दो तिथियों के बीच अंतर की गणना कैसे करें?


722

मेरे पास फॉर्म की दो तारीखें हैं:

Start Date: 2007-03-24 
End Date: 2009-06-26

अब मुझे निम्नलिखित रूप में इन दोनों के बीच अंतर खोजने की आवश्यकता है:

2 years, 3 months and 2 days

मैं इसे PHP में कैसे कर सकता हूं?


1
2 साल 94 दिन। महीनों की गणना, लीप के वर्षों को ध्यान में रखते हुए, समस्याग्रस्त होगी। यह होना कितना सही है?
dbasnett

जवाबों:


526

इसका उपयोग विरासत कोड (PHP <5.3) के लिए करें। अद्यतित समाधान के लिए नीचे जुरका का उत्तर देखें

आप दो तिथियों को यूनिक्स समय में बदलने के लिए स्ट्रेटोटाइम () का उपयोग कर सकते हैं और फिर उनके बीच सेकंड की संख्या की गणना कर सकते हैं। इससे अलग-अलग समय अवधि की गणना करना आसान है।

$date1 = "2007-03-24";
$date2 = "2009-06-26";

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

printf("%d years, %d months, %d days\n", $years, $months, $days);

संपादित करें: स्पष्ट रूप से ऐसा करने का पसंदीदा तरीका नीचे दिए गए जुर्का द्वारा वर्णित है। यदि आपके पास PHP 5.3 या बेहतर नहीं है तो मेरा कोड आमतौर पर केवल अनुशंसित है।

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

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

<?php

/**
 * Calculate differences between two dates with precise semantics. Based on PHPs DateTime::diff()
 * implementation by Derick Rethans. Ported to PHP by Emil H, 2011-05-02. No rights reserved.
 * 
 * See here for original code:
 * http://svn.php.net/viewvc/php/php-src/trunk/ext/date/lib/tm2unixtime.c?revision=302890&view=markup
 * http://svn.php.net/viewvc/php/php-src/trunk/ext/date/lib/interval.c?revision=298973&view=markup
 */

function _date_range_limit($start, $end, $adj, $a, $b, $result)
{
    if ($result[$a] < $start) {
        $result[$b] -= intval(($start - $result[$a] - 1) / $adj) + 1;
        $result[$a] += $adj * intval(($start - $result[$a] - 1) / $adj + 1);
    }

    if ($result[$a] >= $end) {
        $result[$b] += intval($result[$a] / $adj);
        $result[$a] -= $adj * intval($result[$a] / $adj);
    }

    return $result;
}

function _date_range_limit_days($base, $result)
{
    $days_in_month_leap = array(31, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31);
    $days_in_month = array(31, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31);

    _date_range_limit(1, 13, 12, "m", "y", &$base);

    $year = $base["y"];
    $month = $base["m"];

    if (!$result["invert"]) {
        while ($result["d"] < 0) {
            $month--;
            if ($month < 1) {
                $month += 12;
                $year--;
            }

            $leapyear = $year % 400 == 0 || ($year % 100 != 0 && $year % 4 == 0);
            $days = $leapyear ? $days_in_month_leap[$month] : $days_in_month[$month];

            $result["d"] += $days;
            $result["m"]--;
        }
    } else {
        while ($result["d"] < 0) {
            $leapyear = $year % 400 == 0 || ($year % 100 != 0 && $year % 4 == 0);
            $days = $leapyear ? $days_in_month_leap[$month] : $days_in_month[$month];

            $result["d"] += $days;
            $result["m"]--;

            $month++;
            if ($month > 12) {
                $month -= 12;
                $year++;
            }
        }
    }

    return $result;
}

function _date_normalize($base, $result)
{
    $result = _date_range_limit(0, 60, 60, "s", "i", $result);
    $result = _date_range_limit(0, 60, 60, "i", "h", $result);
    $result = _date_range_limit(0, 24, 24, "h", "d", $result);
    $result = _date_range_limit(0, 12, 12, "m", "y", $result);

    $result = _date_range_limit_days(&$base, &$result);

    $result = _date_range_limit(0, 12, 12, "m", "y", $result);

    return $result;
}

/**
 * Accepts two unix timestamps.
 */
function _date_diff($one, $two)
{
    $invert = false;
    if ($one > $two) {
        list($one, $two) = array($two, $one);
        $invert = true;
    }

    $key = array("y", "m", "d", "h", "i", "s");
    $a = array_combine($key, array_map("intval", explode(" ", date("Y m d H i s", $one))));
    $b = array_combine($key, array_map("intval", explode(" ", date("Y m d H i s", $two))));

    $result = array();
    $result["y"] = $b["y"] - $a["y"];
    $result["m"] = $b["m"] - $a["m"];
    $result["d"] = $b["d"] - $a["d"];
    $result["h"] = $b["h"] - $a["h"];
    $result["i"] = $b["i"] - $a["i"];
    $result["s"] = $b["s"] - $a["s"];
    $result["invert"] = $invert ? 1 : 0;
    $result["days"] = intval(abs(($one - $two)/86400));

    if ($invert) {
        _date_normalize(&$a, &$result);
    } else {
        _date_normalize(&$b, &$result);
    }

    return $result;
}

$date = "1986-11-10 19:37:22";

print_r(_date_diff(strtotime($date), time()));
print_r(_date_diff(time(), strtotime($date)));

1
यदि आप DateTime क्लास का उपयोग कर रहे हैं, तो आप यूनिक्स टाइमस्टैम्प प्राप्त करने के लिए $ date-> फॉर्मेट ('U') में जा सकते हैं।
जॉन क्रैम

4
यह सच नहीं है अगर आपको गर्मी / सर्दी के समय से निपटना है। इस विशेष मामले में जब आप गर्मियों / सर्दियों के समय को समायोजित करते हैं, तो एक दिन 23 या 25 घंटे के बराबर होता है।
अर्नो

4
ठीक है, लीप वर्षों के लिए एक ही तर्क दिया जा सकता है। यह भी ध्यान में नहीं लेता है। फिर भी, मुझे विश्वास नहीं हो रहा है कि आप भी इसे ध्यान में रखना चाहते हैं क्योंकि हम यहाँ एक सीमा पर चर्चा कर रहे हैं। एक सीमा के शब्दार्थ निरपेक्ष तिथि के लिए कुछ भिन्न होते हैं।
एमिल एच

9
यह कार्य गलत है। यह एक अनुमान के लिए अच्छा है, लेकिन सटीक सीमाओं के लिए गलत है। एक के लिए, यह मानता है कि एक महीने में 30 दिन होते हैं, जो यह कहना है कि 1 फरवरी और 1 मार्च के बीच के दिनों का समान अंतर होगा क्योंकि यह 1 जुलाई से 1 अगस्त तक (लीप वर्ष की परवाह किए बिना) होगा।
एनोब्रेव

1
PHP में, संदर्भ चर फ़ंक्शन हस्ताक्षर में हैं, कॉल नहीं। अपने सभी &हस्ताक्षरों को स्थानांतरित करें ।
पॉल टारजन

909

मैं DateTime और DateInterval ऑब्जेक्ट्स का उपयोग करने का सुझाव देता हूं।

$date1 = new DateTime("2007-03-24");
$date2 = new DateTime("2009-06-26");
$interval = $date1->diff($date2);
echo "difference " . $interval->y . " years, " . $interval->m." months, ".$interval->d." days "; 

// shows the total amount of days (not divided into years, months and days like above)
echo "difference " . $interval->days . " days ";

और पढ़ें php DateTime :: मैनुअल को अलग करें

मैनुअल से:

PHP 5.2.2 के रूप में, डेटटाइम ऑब्जेक्ट्स की तुलना ऑपरेटर के उपयोग से की जा सकती है।

$date1 = new DateTime("now");
$date2 = new DateTime("tomorrow");

var_dump($date1 == $date2); // bool(false)
var_dump($date1 < $date2);  // bool(true)
var_dump($date1 > $date2);  // bool(false)

14
+1 डेटटाइम ठीक से लीप वर्ष और समय-क्षेत्र को संभालता है और शेल्फ के लिए एक अच्छी किताब है: phparch.com/books/…
hakre

3
क्या कोई विधि है जो दो DateTimes के बीच की कुल संख्या सेकंड देती है? (घटकों को जोड़ने के बिना, वह है)
पोटेटो

1
@Panique $ अंतराल-> दिन और $ अंतराल-> d अलग-अलग उपाय हैं। आपकी टिप्पणी ऊपर सही है "दिन की कुल राशि दिखाता है (ऊपर वर्षों, महीनों और दिनों की तरह विभाजित नहीं)"
जुर्का

1
@potatoe आप शायद चाहते हैं $date2->format('U') - $date1->format('U')
पाउलो फ्रीटास

3
ध्यान दें कि वहाँ एक बग है जहाँ DateInterval में कुछ PHP संस्करणों के साथ विंडोज पर एक गलत दिनों की संपत्ति ( हमेशा 6015 ) है: Bugs.php.net/bug.php?id=51184 (फिक्स / वर्कअराउंड के लिए टिप्पणियों का संदर्भ दें)
पिम स्कैफ

73

कार्रवाई का सबसे अच्छा कोर्स PHP DateTime(और DateInterval) ऑब्जेक्ट का उपयोग कर रहा है । प्रत्येक दिनांक को किसी DateTimeऑब्जेक्ट में एन्क्रिप्ट किया गया है, और फिर दोनों के बीच अंतर किया जा सकता है:

$first_date = new DateTime("2012-11-30 17:03:30");
$second_date = new DateTime("2012-12-21 00:00:00");

DateTimeवस्तु को स्वीकार करेंगे किसी भी प्रारूप strtotime()होगा। यदि और भी विशिष्ट दिनांक प्रारूप की आवश्यकता है, DateTime::createFromFormat()तो DateTimeवस्तु बनाने के लिए उपयोग किया जा सकता है ।

दोनों ऑब्जेक्ट्स को तत्काल किए जाने के बाद, आप एक को दूसरे से अलग करते हैं DateTime::diff()

$difference = $first_date->diff($second_date);

$differenceअब DateIntervalअंतर जानकारी के साथ एक वस्तु रखता है । एक var_dump()ऐसा दिखता है:

object(DateInterval)
  public 'y' => int 0
  public 'm' => int 0
  public 'd' => int 20
  public 'h' => int 6
  public 'i' => int 56
  public 's' => int 30
  public 'invert' => int 0
  public 'days' => int 20

DateIntervalऑब्जेक्ट को प्रारूपित करने के लिए , हमें प्रत्येक मान की जाँच करनी होगी और इसे बाहर करना होगा यदि यह 0 है:

/**
 * Format an interval to show all existing components.
 * If the interval doesn't have a time component (years, months, etc)
 * That component won't be displayed.
 *
 * @param DateInterval $interval The interval
 *
 * @return string Formatted interval string.
 */
function format_interval(DateInterval $interval) {
    $result = "";
    if ($interval->y) { $result .= $interval->format("%y years "); }
    if ($interval->m) { $result .= $interval->format("%m months "); }
    if ($interval->d) { $result .= $interval->format("%d days "); }
    if ($interval->h) { $result .= $interval->format("%h hours "); }
    if ($interval->i) { $result .= $interval->format("%i minutes "); }
    if ($interval->s) { $result .= $interval->format("%s seconds "); }

    return $result;
}

अब जो कुछ बचा है वह $difference DateIntervalवस्तु पर हमारे फ़ंक्शन को कॉल करना है:

echo format_interval($difference);

और हमें सही परिणाम मिलता है:

20 दिन 6 घंटे 56 मिनट 30 सेकंड

लक्ष्य प्राप्त करने के लिए उपयोग किया गया पूरा कोड:

/**
 * Format an interval to show all existing components.
 * If the interval doesn't have a time component (years, months, etc)
 * That component won't be displayed.
 *
 * @param DateInterval $interval The interval
 *
 * @return string Formatted interval string.
 */
function format_interval(DateInterval $interval) {
    $result = "";
    if ($interval->y) { $result .= $interval->format("%y years "); }
    if ($interval->m) { $result .= $interval->format("%m months "); }
    if ($interval->d) { $result .= $interval->format("%d days "); }
    if ($interval->h) { $result .= $interval->format("%h hours "); }
    if ($interval->i) { $result .= $interval->format("%i minutes "); }
    if ($interval->s) { $result .= $interval->format("%s seconds "); }

    return $result;
}

$first_date = new DateTime("2012-11-30 17:03:30");
$second_date = new DateTime("2012-12-21 00:00:00");

$difference = $first_date->diff($second_date);

echo format_interval($difference);

DateTime()कोई फ़ंक्शन नहीं है, यह एक ऑब्जेक्ट है, और यह PHP 5.2 के बाद से है। सुनिश्चित करें कि आपका सर्वर इसका समर्थन करता है।
मदार का भूत

2
@SecondRikudo दिनांक समय :: डिफेंस की जरूरत PHP 5.3.0
फोनिक्स

हमारे पास एक समस्या है, first_date को दूसरे_डेट में बदले और हम एक ही परिणाम प्राप्त कर रहे हैं? क्यों नहीं 0 दिन 0 घंटे 0 मिनट 0 सेकंड या केवल 0. कहते हैं उदाहरण: 2012-11-30 17:03:30 - 2012-12-21 00:00:00 और 2012-12-21 00:00:00 - 2012-11-30 17:03:30 एक ही परिणाम प्राप्त करें।
एगोइस्टड्यूपेलर

क्योंकि अंतर आपको दो समय के बीच का अंतर देता है। अंतर 0 नहीं है, चाहे जो भी बाद में आए।
मदार का भूत

1
यह वास्तव में एक अच्छा जवाब है क्योंकि यह एक स्पष्ट कार्य प्रदान करता है जिसे बहुत सारे समय बछड़ों के बिना कोडबेस में कहीं से भी बुलाया जा सकता है। अन्य उत्तर आपको समस्या को हल करने के बजाय लक्षणों पर उड़ान भरने वाले गूंज वाले बछड़ों को छोड़ने की अनुमति देते हैं ... एकमात्र तत्व जो मैंने जोड़ा है (और अन्य सभी पोस्ट इसे कवर नहीं करते हैं) $ अंतराल तत्वों का बहुवचन है अगर अधिक से अधिक
निकर

33

घंटे और मिनट और सेकंड देखें ..

$date1 = "2008-11-01 22:45:00"; 

$date2 = "2009-12-04 13:44:01"; 

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

$hours   = floor(($diff - $years * 365*60*60*24 - $months*30*60*60*24 - $days*60*60*24)/ (60*60)); 

$minuts  = floor(($diff - $years * 365*60*60*24 - $months*30*60*60*24 - $days*60*60*24 - $hours*60*60)/ 60); 

$seconds = floor(($diff - $years * 365*60*60*24 - $months*30*60*60*24 - $days*60*60*24 - $hours*60*60 - $minuts*60)); 

printf("%d years, %d months, %d days, %d hours, %d minuts\n, %d seconds\n", $years, $months, $days, $hours, $minuts, $seconds); 

7
संभवतः यह सटीक परिणाम नहीं देगा।
डॉल्फिन

8
और एक भयानक समाधान है जब तक कि आप PHP के बहुत पुराने संस्करण का उपयोग करने के लिए मजबूर नहीं होते हैं ...
rdlowrey

2
ऐसा नहीं है DRY । उदाहरण के लिए, 60 * 60 * 24 को 15 बार दोहराया जाता है। लंबे समय तक लाइव कॉपी-पेस्ट का पुन: उपयोग!
पीटर मोर्टेंसन

लीप वर्ष के बारे में क्या? एक वर्ष औसतन 365 दिन नहीं होता है।
पीटर मोर्टेंसन

यह कोड मानता है कि एक महीने में औसतन 30 दिन होते हैं। यहां तक ​​कि एक वर्ष के लिए 365 दिन मानते हुए, एक औसत महीना 365/12 = 30.42 दिन (लगभग) है।
पीटर मोर्टेंसन

18

निम्नलिखित लिंक पर एक नज़र डालें। यह मैंने अब तक पाया सबसे अच्छा जवाब है .. :)

function dateDiff ($d1, $d2) {

    // Return the number of days between the two dates:    
    return round(abs(strtotime($d1) - strtotime($d2))/86400);

} // end function dateDiff

इससे कोई फर्क नहीं पड़ता कि आप कौन से दिनांक पहले या बाद में हैं जब आप दिनांक मापदंडों में पास होते हैं। फ़ंक्शन हमेशा दो तिथियों के बीच दिनों की संख्या के रूप में एक postive संख्या को वापस करने के लिए PHP ABS () निरपेक्ष मूल्य का उपयोग करता है।

ध्यान रखें कि दोनों तिथियों के बीच दिनों की संख्या दोनों तिथियों में सम्मिलित नहीं है। इसलिए यदि आप प्रवेश की गई तारीखों के बीच और उन सभी तारीखों का प्रतिनिधित्व करते हैं, जिनमें आप शामिल हैं, तो आपको इस फ़ंक्शन के परिणाम में एक (1) जोड़ना होगा।

उदाहरण के लिए, 2013-02-09 और 2013-02-14 के बीच का अंतर (जैसा कि उपरोक्त फ़ंक्शन द्वारा दिया गया है) 5. है लेकिन दिनांक 2013-02-09 - 2013-02- १४ ६ है।

http://www.bizinfosys.com/php/date-difference.html


प्रश्न में वर्षों, महीनों और दिनों की संख्या के रूप में अंतर के लिए पूछा गया था, न कि कुल दिनों की संख्या।
पीटर मोर्टेंसन

14

मैंने jurka के जवाब के लिए मतदान किया क्योंकि यह मेरा पसंदीदा है, लेकिन मेरे पास पूर्व-ph.5.5.3 संस्करण है ...

मैंने खुद को एक ऐसी ही समस्या पर काम करते हुए पाया - जो कि मुझे इस सवाल से पहली बार में कैसे लगी - लेकिन बस कुछ ही घंटों में फर्क पड़ गया। लेकिन मेरे कार्य ने इसे बहुत अच्छी तरह से हल कर दिया और मेरे पास अपनी लाइब्रेरी में कहीं भी नहीं है इसे रखने के लिए जहां यह खो जाएगा और भूल नहीं जाएगा, इसलिए ... उम्मीद है कि यह किसी के लिए उपयोगी है।

/**
 *
 * @param DateTime $oDate1
 * @param DateTime $oDate2
 * @return array 
 */
function date_diff_array(DateTime $oDate1, DateTime $oDate2) {
    $aIntervals = array(
        'year'   => 0,
        'month'  => 0,
        'week'   => 0,
        'day'    => 0,
        'hour'   => 0,
        'minute' => 0,
        'second' => 0,
    );

    foreach($aIntervals as $sInterval => &$iInterval) {
        while($oDate1 <= $oDate2){ 
            $oDate1->modify('+1 ' . $sInterval);
            if ($oDate1 > $oDate2) {
                $oDate1->modify('-1 ' . $sInterval);
                break;
            } else {
                $iInterval++;
            }
        }
    }

    return $aIntervals;
}

और परीक्षण:

$oDate = new DateTime();
$oDate->modify('+111402189 seconds');
var_dump($oDate);
var_dump(date_diff_array(new DateTime(), $oDate));

और परिणाम:

object(DateTime)[2]
  public 'date' => string '2014-04-29 18:52:51' (length=19)
  public 'timezone_type' => int 3
  public 'timezone' => string 'America/New_York' (length=16)

array
  'year'   => int 3
  'month'  => int 6
  'week'   => int 1
  'day'    => int 4
  'hour'   => int 9
  'minute' => int 3
  'second' => int 8

मुझे यहां से मूल विचार मिला जो मैं अपने उपयोग के लिए संशोधित, (और मुझे आशा है कि मेरी संशोधन के साथ ही उस पृष्ठ पर दिखाई देगा)।

आप बहुत आसानी से उन अंतरालों को हटा सकते हैं जो आपको नहीं चाहिए ("सप्ताह") उन्हें $aIntervalsसरणी से हटाकर , या शायद एक $aExcludeपैरामीटर जोड़कर , या जब आप स्ट्रिंग का उत्पादन करते हैं तो उन्हें फ़िल्टर करें।


दुर्भाग्य से यह वर्ष / महीने की अधिकता के कारण डेटइंटरवल के समान नहीं है।
स्टीफन हैरिस

2
@StephenHarris: मैंने इसका परीक्षण नहीं किया है, लेकिन कोड को पढ़कर मुझे पूरा विश्वास है कि इसे उसी परिणाम को वापस करना चाहिए - बशर्ते कि आप इसमें weekइंडेक्स को हटा दें $aIntervals(क्योंकि यह DateDiffकभी उपयोग नहीं करता है)।
एलिक्स एक्सल

यह उन तिथियों को खोजने के लिए एक महान समाधान है जो दो तिथियों के बीच हर अंतराल पर होते हैं।
18:09

14
<?php
    $today = strtotime("2011-02-03 00:00:00");
    $myBirthDate = strtotime("1964-10-30 00:00:00");
    printf("Days since my birthday: ", ($today - $myBirthDate)/60/60/24);
?>

प्रश्न में वर्षों , महीनों और दिनों की संख्या के अंतर के लिए पूछा गया था । यह अंतर को कुल दिनों की संख्या के रूप में बदलता है।
पीटर मोर्टेंसन

11

मुझे नहीं पता कि आप एक PHP फ्रेमवर्क का उपयोग कर रहे हैं या नहीं, लेकिन बहुत सारे PHP फ्रेमवर्क में आपको व्हील को फिर से स्थापित करने में मदद करने के लिए डेट / टाइम लाइब्रेरी और हेल्पर्स हैं।

उदाहरण के लिए CodeIgniter का timespan()कार्य है। बस दो यूनिक्स टाइमस्टैम्प इनपुट करें और यह स्वचालित रूप से इस तरह एक परिणाम उत्पन्न करेगा:

1 Year, 10 Months, 2 Weeks, 5 Days, 10 Hours, 16 Minutes

http://codeigniter.com/user_guide/helpers/date_helper.html


8

उदाहरण का उपयोग करें:

echo time_diff_string('2013-05-01 00:22:35', 'now');
echo time_diff_string('2013-05-01 00:22:35', 'now', true);

आउटपुट:

4 months ago
4 months, 2 weeks, 3 days, 1 hour, 49 minutes, 15 seconds ago

समारोह :

function time_diff_string($from, $to, $full = false) {
    $from = new DateTime($from);
    $to = new DateTime($to);
    $diff = $to->diff($from);

    $diff->w = floor($diff->d / 7);
    $diff->d -= $diff->w * 7;

    $string = array(
        'y' => 'year',
        'm' => 'month',
        'w' => 'week',
        'd' => 'day',
        'h' => 'hour',
        'i' => 'minute',
        's' => 'second',
    );
    foreach ($string as $k => &$v) {
        if ($diff->$k) {
            $v = $diff->$k . ' ' . $v . ($diff->$k > 1 ? 's' : '');
        } else {
            unset($string[$k]);
        }
    }

    if (!$full) $string = array_slice($string, 0, 1);
    return $string ? implode(', ', $string) . ' ago' : 'just now';
}

अगर मैं यह निर्धारित करना चाहता हूं कि यदि अंतर बड़ा है तो 30 मिनट, मुझे क्या करना चाहिए?
इतिर अटिया

@OfirAttia: आपके पास SO पर यहां जैसे प्रश्नों का एक गुच्छा है, बस खोज का उपयोग करें। सरल डेमो
Glavić

7

मेरे पास इसके लिए कुछ सरल तर्क हैं:

<?php
    per_days_diff('2011-12-12','2011-12-29')
    function per_days_diff($start_date, $end_date) {
        $per_days = 0;
        $noOfWeek = 0;
        $noOfWeekEnd = 0;
        $highSeason=array("7", "8");

        $current_date = strtotime($start_date);
        $current_date += (24 * 3600);
        $end_date = strtotime($end_date);

        $seassion = (in_array(date('m', $current_date), $highSeason))?"2":"1";

        $noOfdays = array('');

        while ($current_date <= $end_date) {
            if ($current_date <= $end_date) {
                $date = date('N', $current_date);
                array_push($noOfdays,$date);
                $current_date = strtotime('+1 day', $current_date);
            }
        }

        $finalDays = array_shift($noOfdays);
        //print_r($noOfdays);
        $weekFirst = array("week"=>array(),"weekEnd"=>array());
        for($i = 0; $i < count($noOfdays); $i++)
        {
            if ($noOfdays[$i] == 1)
            {
                //echo "This is week";
                //echo "<br/>";
                if($noOfdays[$i+6]==7)
                {
                    $noOfWeek++;
                    $i=$i+6;
                }
                else
                {
                    $per_days++;
                }
                //array_push($weekFirst["week"],$day);
            }
            else if($noOfdays[$i]==5)
            {
                //echo "This is weekend";
                //echo "<br/>";
                if($noOfdays[$i+2] ==7)
                {
                    $noOfWeekEnd++;
                    $i = $i+2;
                }
                else
                {
                    $per_days++;
                }
                //echo "After weekend value:- ".$i;
                //echo "<br/>";
            }
            else
            {
                $per_days++;
            }
        }

        /*echo $noOfWeek;
          echo "<br/>";
          echo $noOfWeekEnd;
          echo "<br/>";
          print_r($per_days);
          echo "<br/>";
          print_r($weekFirst);
        */

        $duration = array("weeks"=>$noOfWeek, "weekends"=>$noOfWeekEnd, "perDay"=>$per_days, "seassion"=>$seassion);
        return $duration;
      ?>

नमूना कोड के अंत में कुछ याद आ रहा है (एक समाप्त ब्रेस और " ?> "?)।
पीटर मोर्टेंसन

"सरल" तर्क। ये शुद्ध कोड की कम से कम 40 लाइनें हैं।
मज्जोज

6

आप उपयोग कर सकते हैं

getdate()

वह फ़ंक्शन जो किसी ऐसे सरणी को देता है जिसमें आपूर्ति की गई तिथि / समय के सभी तत्व शामिल हैं:

$diff = abs($endDate - $startDate);
$my_t=getdate($diff);
print("$my_t[year] years, $my_t[month] months and $my_t[mday] days");

यदि आपकी आरंभ और समाप्ति तिथि स्ट्रिंग प्रारूप में हैं तो उपयोग करें

$startDate = strtotime($startDateStr);
$endDate = strtotime($endDateStr);

उपरोक्त कोड से पहले


काम करने के लिए प्रतीत नहीं होता है। मुझे टाइमस्टैम्प युग की शुरुआत में एक तारीख मिलती है।
सिरबर

यह समझना महत्वपूर्ण है कि आपको $my_t["year"] -= 1970सही संख्या में वर्षों की आवश्यकता है। घंटे सही करने के लिए आपको GMT से अपने घंटे के अंतर को घटाना भी होगा। आपको महीने और तारीख से 1 भी घटाना होगा।
सलमान एक

6
// If you just want to see the year difference then use this function.
// Using the logic I've created you may also create month and day difference
// which I did not provide here so you may have the efforts to use your brain.
// :)
$date1='2009-01-01';
$date2='2010-01-01';
echo getYearDifference ($date1,$date2);
function getYearDifference($date1=strtotime($date1),$date2=strtotime($date2)){
    $year = 0;
    while($date2 > $date1 = strtotime('+1 year', $date1)){
        ++$year;
    }
    return $year;
}

क्या "स्ट्रेटोटाइम ('+ 1 वर्ष', $ date1)" लीप वर्ष को ध्यान में रखता है?
पीटर मोर्टेंसन

6

यह मेरा कार्य है। आवश्यक PHP> = 5.3.4। यह DateTime क्लास का उपयोग करता है। बहुत तेज, त्वरित और दो तिथियों या यहां तक ​​कि तथाकथित "समय से" के बीच अंतर कर सकता है।

if(function_exists('grk_Datetime_Since') === FALSE){
    function grk_Datetime_Since($From, $To='', $Prefix='', $Suffix=' ago', $Words=array()){
        #   Est-ce qu'on calcul jusqu'à un moment précis ? Probablement pas, on utilise maintenant
        if(empty($To) === TRUE){
            $To = time();
        }

        #   On va s'assurer que $From est numérique
        if(is_int($From) === FALSE){
            $From = strtotime($From);
        };

        #   On va s'assurer que $To est numérique
        if(is_int($To) === FALSE){
            $To = strtotime($To);
        }

        #   On a une erreur ?
        if($From === FALSE OR $From === -1 OR $To === FALSE OR $To === -1){
            return FALSE;
        }

        #   On va créer deux objets de date
        $From = new DateTime(@date('Y-m-d H:i:s', $From), new DateTimeZone('GMT'));
        $To   = new DateTime(@date('Y-m-d H:i:s', $To), new DateTimeZone('GMT'));

        #   On va calculer la différence entre $From et $To
        if(($Diff = $From->diff($To)) === FALSE){
            return FALSE;
        }

        #   On va merger le tableau des noms (par défaut, anglais)
        $Words = array_merge(array(
            'year'      => 'year',
            'years'     => 'years',
            'month'     => 'month',
            'months'    => 'months',
            'week'      => 'week',
            'weeks'     => 'weeks',
            'day'       => 'day',
            'days'      => 'days',
            'hour'      => 'hour',
            'hours'     => 'hours',
            'minute'    => 'minute',
            'minutes'   => 'minutes',
            'second'    => 'second',
            'seconds'   => 'seconds'
        ), $Words);

        #   On va créer la chaîne maintenant
        if($Diff->y > 1){
            $Text = $Diff->y.' '.$Words['years'];
        } elseif($Diff->y == 1){
            $Text = '1 '.$Words['year'];
        } elseif($Diff->m > 1){
            $Text = $Diff->m.' '.$Words['months'];
        } elseif($Diff->m == 1){
            $Text = '1 '.$Words['month'];
        } elseif($Diff->d > 7){
            $Text = ceil($Diff->d/7).' '.$Words['weeks'];
        } elseif($Diff->d == 7){
            $Text = '1 '.$Words['week'];
        } elseif($Diff->d > 1){
            $Text = $Diff->d.' '.$Words['days'];
        } elseif($Diff->d == 1){
            $Text = '1 '.$Words['day'];
        } elseif($Diff->h > 1){
            $Text = $Diff->h.' '.$Words['hours'];
        } elseif($Diff->h == 1){
            $Text = '1 '.$Words['hour'];
        } elseif($Diff->i > 1){
            $Text = $Diff->i.' '.$Words['minutes'];
        } elseif($Diff->i == 1){
            $Text = '1 '.$Words['minute'];
        } elseif($Diff->s > 1){
            $Text = $Diff->s.' '.$Words['seconds'];
        } else {
            $Text = '1 '.$Words['second'];
        }

        return $Prefix.$Text.$Suffix;
    }
}

6

मैं उपयोग date_createऔर date_diffवस्तुओं को प्राथमिकता दूंगा।

कोड:

$date1 = date_create("2007-03-24");
$date2 = date_create("2009-06-26");

$dateDifference = date_diff($date1, $date2)->format('%y years, %m months and %d days');

echo $dateDifference;

आउटपुट:

2 years, 3 months and 2 days

अधिक जानकारी के लिए PHP मैनुअल पढ़ेंdate_diff

मैनुअल के अनुसार डेटाइमdate_diff का एक उपनाम है : अंतर ()


5

यह पता लगाने की कोशिश की जाएगी कि टाइमस्टैम्प दिया गया था या नहीं, और नकारात्मक मूल्यों के रूप में भविष्य की तारीखें / समय भी लौटाएगा:

<?php

function time_diff($start, $end = NULL, $convert_to_timestamp = FALSE) {
  // If $convert_to_timestamp is not explicitly set to TRUE,
  // check to see if it was accidental:
  if ($convert_to_timestamp || !is_numeric($start)) {
    // If $convert_to_timestamp is TRUE, convert to timestamp:
    $timestamp_start = strtotime($start);
  }
  else {
    // Otherwise, leave it as a timestamp:
    $timestamp_start = $start;
  }
  // Same as above, but make sure $end has actually been overridden with a non-null,
  // non-empty, non-numeric value:
  if (!is_null($end) && (!empty($end) && !is_numeric($end))) {
    $timestamp_end = strtotime($end);
  }
  else {
    // If $end is NULL or empty and non-numeric value, assume the end time desired
    // is the current time (useful for age, etc):
    $timestamp_end = time();
  }
  // Regardless, set the start and end times to an integer:
  $start_time = (int) $timestamp_start;
  $end_time = (int) $timestamp_end;

  // Assign these values as the params for $then and $now:
  $start_time_var = 'start_time';
  $end_time_var = 'end_time';
  // Use this to determine if the output is positive (time passed) or negative (future):
  $pos_neg = 1;

  // If the end time is at a later time than the start time, do the opposite:
  if ($end_time <= $start_time) {
    $start_time_var = 'end_time';
    $end_time_var = 'start_time';
    $pos_neg = -1;
  }

  // Convert everything to the proper format, and do some math:
  $then = new DateTime(date('Y-m-d H:i:s', $$start_time_var));
  $now = new DateTime(date('Y-m-d H:i:s', $$end_time_var));

  $years_then = $then->format('Y');
  $years_now = $now->format('Y');
  $years = $years_now - $years_then;

  $months_then = $then->format('m');
  $months_now = $now->format('m');
  $months = $months_now - $months_then;

  $days_then = $then->format('d');
  $days_now = $now->format('d');
  $days = $days_now - $days_then;

  $hours_then = $then->format('H');
  $hours_now = $now->format('H');
  $hours = $hours_now - $hours_then;

  $minutes_then = $then->format('i');
  $minutes_now = $now->format('i');
  $minutes = $minutes_now - $minutes_then;

  $seconds_then = $then->format('s');
  $seconds_now = $now->format('s');
  $seconds = $seconds_now - $seconds_then;

  if ($seconds < 0) {
    $minutes -= 1;
    $seconds += 60;
  }
  if ($minutes < 0) {
    $hours -= 1;
    $minutes += 60;
  }
  if ($hours < 0) {
    $days -= 1;
    $hours += 24;
  }
  $months_last = $months_now - 1;
  if ($months_now == 1) {
    $years_now -= 1;
    $months_last = 12;
  }

  // "Thirty days hath September, April, June, and November" ;)
  if ($months_last == 9 || $months_last == 4 || $months_last == 6 || $months_last == 11) {
    $days_last_month = 30;
  }
  else if ($months_last == 2) {
    // Factor in leap years:
    if (($years_now % 4) == 0) {
      $days_last_month = 29;
    }
    else {
      $days_last_month = 28;
    }
  }
  else {
    $days_last_month = 31;
  }
  if ($days < 0) {
    $months -= 1;
    $days += $days_last_month;
  }
  if ($months < 0) {
    $years -= 1;
    $months += 12;
  }

  // Finally, multiply each value by either 1 (in which case it will stay the same),
  // or by -1 (in which case it will become negative, for future dates).
  // Note: 0 * 1 == 0 * -1 == 0
  $out = new stdClass;
  $out->years = (int) $years * $pos_neg;
  $out->months = (int) $months * $pos_neg;
  $out->days = (int) $days * $pos_neg;
  $out->hours = (int) $hours * $pos_neg;
  $out->minutes = (int) $minutes * $pos_neg;
  $out->seconds = (int) $seconds * $pos_neg;
  return $out;
}

उदाहरण उपयोग:

<?php
  $birthday = 'June 2, 1971';
  $check_age_for_this_date = 'June 3, 1999 8:53pm';
  $age = time_diff($birthday, $check_age_for_this_date)->years;
  print $age;// 28

या:

<?php
  $christmas_2020 = 'December 25, 2020';
  $countdown = time_diff($christmas_2020);
  print_r($countdown);

5

"अगर" तिथि MySQL में संग्रहीत है, तो मुझे डेटाबेस स्तर पर अंतर गणना करना आसान लगता है ... फिर दिन, घंटा, न्यूनतम, सेक आउटपुट, पार्स और प्रदर्शन परिणामों के आधार पर उपयुक्त ...

mysql> select firstName, convert_tz(loginDate, '+00:00', '-04:00') as loginDate, TIMESTAMPDIFF(DAY, loginDate, now()) as 'Day', TIMESTAMPDIFF(HOUR, loginDate, now())+4 as 'Hour', TIMESTAMPDIFF(MINUTE, loginDate, now())+(60*4) as 'Min', TIMESTAMPDIFF(SECOND, loginDate, now())+(60*60*4) as 'Sec' from User_ where userId != '10158' AND userId != '10198' group by emailAddress order by loginDate desc;
 +-----------+---------------------+------+------+------+--------+
 | firstName | loginDate           | Day  | Hour | Min  | Sec    |
 +-----------+---------------------+------+------+------+--------+
 | Peter     | 2014-03-30 18:54:40 |    0 |    4 |  244 |  14644 |
 | Keith     | 2014-03-30 18:54:11 |    0 |    4 |  244 |  14673 |
 | Andres    | 2014-03-28 09:20:10 |    2 |   61 | 3698 | 221914 |
 | Nadeem    | 2014-03-26 09:33:43 |    4 |  109 | 6565 | 393901 |
 +-----------+---------------------+------+------+------+--------+
 4 rows in set (0.00 sec)

5

मैंने आपका लेख निम्नलिखित पेज पर पाया, जिसमें PHP की तारीख की गणना के लिए कई संदर्भ हैं ।

PHP का उपयोग करके दो तिथियों (और समय) के बीच अंतर की गणना करें। निम्न पृष्ठ दो तिथियों के बीच समय (घंटे, munites), दिनों, महीनों या वर्षों में अंतर निर्धारित करने के लिए PHP का उपयोग करते हुए दिनांक / समय गणना करने के लिए विभिन्न तरीकों (कुल में 7) की एक सीमा प्रदान करता है।

2 तिथियों के बीच अंतर की गणना करने के लिए PHP दिनांक समय - 7 तरीके देखें ।


4

आप निम्नलिखित दिनांक का उपयोग भी कर सकते हैं, $ date1 = $ duedate तक गोल अंशों द्वारा भिन्न होने की तिथि; // नियत दिनांक इको $ date2 = date ("Ymd") असाइन करें; // वर्तमान तिथि $ ts1 = स्ट्रेटोटाइम ($ date1); $ ts2 = strtotime ($ date2); $ सेकंड_डिफ़ = $ ts1 - $ ts2; गूंज $ datediff = छत (($ सेकंड_डिफ़ / 3600) / 24); // दिन में वापसी

यदि आप छत के बजाय php के फर्श विधि का उपयोग करते हैं तो यह आपको गोल अंश नीचे लौटा देगा। कृपया यहां अंतर की जांच करें, अगर कुछ बार आपके स्टेजिंग सर्वर टाइमज़ोन अलग हैं तो उस स्थिति में लाइव साइट टाइम ज़ोन आपको अलग-अलग परिणाम मिल सकता है इसलिए तदनुसार स्थितियों को बदलें।


4
$date1 = date_create('2007-03-24');
$date2 = date_create('2009-06-26');
$interval = date_diff($date1, $date2);
echo "difference : " . $interval->y . " years, " . $interval->m." months, ".$interval->d." days ";

4

आप हमेशा निम्नलिखित फ़ंक्शन का उपयोग कर सकते हैं जो वर्षों और महीनों में आयु वापस कर सकते हैं (यानी 1 वर्ष 4 महीने)

function getAge($dob, $age_at_date)
{  
    $d1 = new DateTime($dob);
    $d2 = new DateTime($age_at_date);
    $age = $d2->diff($d1);
    $years = $age->y;
    $months = $age->m;

    return $years.'.'.months;
}

या यदि आप चाहते हैं कि आयु की गणना वर्तमान तिथि में की जाए, तो आप उपयोग कर सकते हैं

function getAge($dob)
{  
    $d1 = new DateTime($dob);
    $d2 = new DateTime(date());
    $age = $d2->diff($d1);
    $years = $age->y;
    $months = $age->m;

    return $years.'.'.months;
}

4

Php संस्करण के लिए> = 5.3: दो दिनांक ऑब्जेक्ट बनाएँ और फिर date_diff()फ़ंक्शन का उपयोग करें। यह php DateInterval ऑब्जेक्ट को लौटाएगाप्रलेखन देखें

$date1=date_create("2007-03-24");
$date2=date_create("2009-06-26");
$diff=date_diff($date1,$date2);
echo $diff->format("%R%a days");

4

यहां रन करने योग्य कोड है

$date1 = date_create('2007-03-24');
$date2 = date_create('2009-06-26');
$diff1 = date_diff($date1,$date2);
$daysdiff = $diff1->format("%R%a");
$daysdiff = abs($daysdiff);

3

मुझे PHP 5.2 के साथ एक ही समस्या थी और इसे MySQL के साथ हल किया। हो सकता है कि वास्तव में आप क्या देख रहे हैं, लेकिन यह चाल नहीं चलेगा और दिनों की संख्या लौटाएगा:

$datediff_q = $dbh->prepare("SELECT DATEDIFF(:date2, :date1)");
$datediff_q->bindValue(':date1', '2007-03-24', PDO::PARAM_STR);
$datediff_q->bindValue(':date2', '2009-06-26', PDO::PARAM_STR);
$datediff = ($datediff_q->execute()) ? $datediff_q->fetchColumn(0) : false;

अधिक जानकारी यहाँ http://dev.mysql.com/doc/refman/5.5/en/date-and-time-functions.html#function_datediff


3

चूंकि हर कोई कोड नमूने पोस्ट कर रहा है, यहां एक और संस्करण है।

मैं कुछ सेकंड से लेकर साल (बस एक इकाई) तक के अंतर को प्रदर्शित करने के लिए एक फ़ंक्शन चाहता था। 1 दिन से अधिक समय के लिए, मैं इसे आधी रात को रोलओवर करना चाहता था (9 बजे बुधवार से देखा जाने वाला 10 सोमवार 2 दिन पहले है, 1 नहीं)। और एक महीने से अधिक समय तक, मैं चाहता था कि रोलओवर महीने के उसी दिन (30/31 दिन के महीनों और लीप वर्ष के लिए) हो।

मैंने ये ढूंढ निकाला:

/**
 * Returns how long ago something happened in the past, showing it
 * as n seconds / minutes / hours / days / weeks / months / years ago.
 *
 * For periods over a day, it rolls over at midnight (so doesn't depend
 * on current time of day), and it correctly accounts for month-lengths
 * and leap-years (months and years rollover on current day of month).
 *
 * $param string $timestamp in DateTime format
 * $return string description of interval
 */
function ago($timestamp)
{
    $then = date_create($timestamp);

    // for anything over 1 day, make it rollover on midnight
    $today = date_create('tomorrow'); // ie end of today
    $diff = date_diff($then, $today);

    if ($diff->y > 0) return $diff->y.' year'.($diff->y>1?'s':'').' ago';
    if ($diff->m > 0) return $diff->m.' month'.($diff->m>1?'s':'').' ago';
    $diffW = floor($diff->d / 7);
    if ($diffW > 0) return $diffW.' week'.($diffW>1?'s':'').' ago';
    if ($diff->d > 1) return $diff->d.' day'.($diff->d>1?'s':'').' ago';

    // for anything less than 1 day, base it off 'now'
    $now = date_create();
    $diff = date_diff($then, $now);

    if ($diff->d > 0) return 'yesterday';
    if ($diff->h > 0) return $diff->h.' hour'.($diff->h>1?'s':'').' ago';
    if ($diff->i > 0) return $diff->i.' minute'.($diff->i>1?'s':'').' ago';
    return $diff->s.' second'.($diff->s==1?'':'s').' ago';
}

3

कुछ समय पहले मैंने एक format_dateफंक्शन लिखा था क्योंकि इससे आपको अपनी तारीख के बारे में कई विकल्प मिलते हैं :

function format_date($date, $type, $seperator="-")
{
    if($date)
    {
        $day = date("j", strtotime($date));
        $month = date("n", strtotime($date));
        $year = date("Y", strtotime($date));
        $hour = date("H", strtotime($date));
        $min = date("i", strtotime($date));
        $sec = date("s", strtotime($date));

        switch($type)
        {
            case 0:  $date = date("Y".$seperator."m".$seperator."d",mktime($hour, $min, $sec, $month, $day, $year)); break;
            case 1:  $date = date("D, F j, Y",mktime($hour, $min, $sec, $month, $day, $year)); break;
            case 2:  $date = date("d".$seperator."m".$seperator."Y",mktime($hour, $min, $sec, $month, $day, $year)); break;
            case 3:  $date = date("d".$seperator."M".$seperator."Y",mktime($hour, $min, $sec, $month, $day, $year)); break;
            case 4:  $date = date("d".$seperator."M".$seperator."Y h:i A",mktime($hour, $min, $sec, $month, $day, $year)); break;
            case 5:  $date = date("m".$seperator."d".$seperator."Y",mktime($hour, $min, $sec, $month, $day, $year)); break;
            case 6:  $date = date("M",mktime($hour, $min, $sec, $month, $day, $year)); break;
            case 7:  $date = date("Y",mktime($hour, $min, $sec, $month, $day, $year)); break;
            case 8:  $date = date("j",mktime($hour, $min, $sec, $month, $day, $year)); break;
            case 9:  $date = date("n",mktime($hour, $min, $sec, $month, $day, $year)); break;
            case 10: 
                     $diff = abs(strtotime($date) - strtotime(date("Y-m-d h:i:s"))); 
                     $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));
                     $date = $years . " years, " . $months . " months, " . $days . "days";
        }
    }
    return($date);
}    

2
यह उत्तर खल्दोनो के उत्तर के समान ही गलत है। यह मानता है (केस 10) कि एक वर्ष में 365 दिन होते हैं (हर चौथे वर्ष में 366 दिन होते हैं (ग्रेगोरियन कैलेंडर के लिए 100 वर्ष / 400 साल के नियमों को छोड़कर)), और यह कि एक महीने में 30 दिन हैं (यह लगभग 30.42 दिन है) गैर-लीप वर्ष में)। बेहतर स्थिरांक के साथ भी यह केवल औसत पर सही है, जरूरी नहीं कि किसी दो विशेष तिथियों के लिए सही हो।
पीटर मॉर्टेंसन

3

बहुत आसान:

    <?php
        $date1 = date_create("2007-03-24");
        echo "Start date: ".$date1->format("Y-m-d")."<br>";
        $date2 = date_create("2009-06-26");
        echo "End date: ".$date2->format("Y-m-d")."<br>";
        $diff = date_diff($date1,$date2);
        echo "Difference between start date and end date: ".$diff->format("%y years, %m months and %d days")."<br>";
    ?>

कृपया विवरण के लिए निम्नलिखित लिंक देखें:

PHP: date_diff - मैनुअल

ध्यान दें कि यह PHP 5.3.0 या अधिक के लिए है।


3

एक आसान कार्य

function time_difference($time_1, $time_2, $limit = null)
{

    $val_1 = new DateTime($time_1);
    $val_2 = new DateTime($time_2);

    $interval = $val_1->diff($val_2);

    $output = array(
        "year" => $interval->y,
        "month" => $interval->m,
        "day" => $interval->d,
        "hour" => $interval->h,
        "minute" => $interval->i,
        "second" => $interval->s
    );

    $return = "";
    foreach ($output AS $key => $value) {

        if ($value == 1)
            $return .= $value . " " . $key . " ";
        elseif ($value >= 1)
            $return .= $value . " " . $key . "s ";

        if ($key == $limit)
            return trim($return);
    }
    return trim($return);
}

का उपयोग करें

echo time_difference ($time_1, $time_2, "day");

जैसे लौटेंगे 2 years 8 months 2 days


3

Date_diff () का उपयोग करके यह बहुत ही सरल उत्तर आज़माएं , यह परीक्षण किया गया है।

$date1 = date_create("2017-11-27");
$date2 = date_create("2018-12-29");
$diff=date_diff($date1,$date2);
$months = $diff->format("%m months");
$years = $diff->format("%y years");
$days = $diff->format("%d days");

echo $years .' '.$months.' '.$days;

आउटपुट है:

1 years 1 months 2 days

2

मैं निम्नलिखित फ़ंक्शन का उपयोग कर रहा हूं जो मैंने लिखा था, जब PHP 5.3 (क्रमशः date_diff ()) उपलब्ध नहीं है:

        function dateDifference($startDate, $endDate)
        {
            $startDate = strtotime($startDate);
            $endDate = strtotime($endDate);
            if ($startDate === false || $startDate < 0 || $endDate === false || $endDate < 0 || $startDate > $endDate)
                return false;

            $years = date('Y', $endDate) - date('Y', $startDate);

            $endMonth = date('m', $endDate);
            $startMonth = date('m', $startDate);

            // Calculate months
            $months = $endMonth - $startMonth;
            if ($months <= 0)  {
                $months += 12;
                $years--;
            }
            if ($years < 0)
                return false;

            // Calculate the days
            $measure = ($months == 1) ? 'month' : 'months';
            $days = $endDate - strtotime('+' . $months . ' ' . $measure, $startDate);
            $days = date('z', $days);   

            return array($years, $months, $days);
        }

2

DateInterval बहुत अच्छा है, लेकिन इसमें दो जोड़े हैं:

  1. केवल PHP 5.3+ के लिए ( लेकिन यह वास्तव में एक अच्छा बहाना नहीं है )
  2. केवल वर्ष, महीने, दिन, घंटे, मिनट और सेकंड का समर्थन करता है (कोई सप्ताह नहीं)
  3. यह उपरोक्त सभी दिनों के साथ अंतर की गणना करता है (आप केवल महीनों में अंतर प्राप्त नहीं कर सकते हैं)

उस पर काबू पाने के लिए, मैंने निम्नलिखित को कोडित किया ( @enobrev उत्तर से सुधार ):

function date_dif($since, $until, $keys = 'year|month|week|day|hour|minute|second')
{
    $date = array_map('strtotime', array($since, $until));

    if ((count($date = array_filter($date, 'is_int')) == 2) && (sort($date) === true))
    {
        $result = array_fill_keys(explode('|', $keys), 0);

        foreach (preg_grep('~^(?:year|month)~i', $result) as $key => $value)
        {
            while ($date[1] >= strtotime(sprintf('+%u %s', $value + 1, $key), $date[0]))
            {
                ++$value;
            }

            $date[0] = strtotime(sprintf('+%u %s', $result[$key] = $value, $key), $date[0]);
        }

        foreach (preg_grep('~^(?:year|month)~i', $result, PREG_GREP_INVERT) as $key => $value)
        {
            if (($value = intval(abs($date[0] - $date[1]) / strtotime(sprintf('%u %s', 1, $key), 0))) > 0)
            {
                $date[0] = strtotime(sprintf('+%u %s', $result[$key] = $value, $key), $date[0]);
            }
        }

        return $result;
    }

    return false;
}

यह दो छोरों को चलाता है; पहले एक रिश्तेदार अंतराल (साल और महीने) के साथ जानवर-बल के माध्यम से संबंधित है, और दूसरा सरल अंकगणित के साथ अतिरिक्त पूर्ण अंतराल की गणना करता है (इसलिए यह तेज है):

echo humanize(date_dif('2007-03-24', '2009-07-31', 'second')); // 74300400 seconds
echo humanize(date_dif('2007-03-24', '2009-07-31', 'minute|second')); // 1238400 minutes, 0 seconds
echo humanize(date_dif('2007-03-24', '2009-07-31', 'hour|minute|second')); // 20640 hours, 0 minutes, 0 seconds
echo humanize(date_dif('2007-03-24', '2009-07-31', 'year|day')); // 2 years, 129 days
echo humanize(date_dif('2007-03-24', '2009-07-31', 'year|week')); // 2 years, 18 weeks
echo humanize(date_dif('2007-03-24', '2009-07-31', 'year|week|day')); // 2 years, 18 weeks, 3 days
echo humanize(date_dif('2007-03-24', '2009-07-31')); // 2 years, 4 months, 1 week, 0 days, 0 hours, 0 minutes, 0 seconds

function humanize($array)
{
    $result = array();

    foreach ($array as $key => $value)
    {
        $result[$key] = $value . ' ' . $key;

        if ($value != 1)
        {
            $result[$key] .= 's';
        }
    }

    return implode(', ', $result);
}

@PeterMortensen: यह काम करना चाहिए, लेकिन मैं कोई गारंटी नहीं देता। अपना समय-क्षेत्र निर्धारित करें और इसे दें।
एलिक्स एक्सल
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.