PHP kullanarak iki tarih arasındaki gün sayısı nasıl bulunur?

$now = time(); // or your date as well
$your_date = strtotime("2010-01-31");
$datediff = $now - $your_date;

echo round($datediff / (60 * 60 * 24));

Eğer kullanıyorsanız PHP 5.3 >, bu farkı hesaplamanın en doğru yoludur:

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

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

PHP Sürüm 5.3 ve sonraki sürümlerden fark yaratmak için yeni tarih / saat işlevleri eklendi:

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

Sonuç aşağıdaki gibi:

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
)

Umarım yardımcı olur !

Tarihlerinizi unix zaman damgalarına dönüştürün, ardından birini diğerinden daha az özetleyin. Bu, size bu aralıktaki yaklaşık gün sayısını vermek için 86400'e (günde saniye sayısı) böldüğünüz saniye cinsinden farkı verecektir.

Tarihlerinizin biçiminde ise 25.1.2010, 01/25/2010ya 2010-01-25kullanabileceğiniz strtotimeişlevi:

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

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

Kullanarak ceilgün sayısını bir sonraki tam güne yuvarlar. floorBu iki tarih arasındaki tam gün miktarını almak istiyorsanız bunun yerine kullanın .

Tarihleriniz zaten unix zaman damgası biçimindeyse, dönüştürmeyi atlayabilir ve yalnızca $days_betweenparçayı yapabilirsiniz. Daha egzotik tarih biçimleri için, doğru olması için bazı özel ayrıştırmalar yapmanız gerekebilir.

TL; DR do not UNIX zaman kullanın. Kullanmayıntime() . Bunu yaparsanız, % 98.0825 güvenilirliği başarısız olursa hazırlıklı olun. DateTime (veya Carbon) kullanın.

Doğru cevap Saksham Gupta (diğer cevaplar da doğru) tarafından verilen biridir:

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

Veya prosedür olarak tek astar olarak:

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

Bir uyarı ile: '% a' mutlak gün sayısını gösterir . İşaretli bir tamsayı olarak, yani ikinci tarih ilkinden önce olduğunda negatif olarak istiyorsanız, '% r' önekini (yani format('%r%a')) kullanmanız gerekir .

Gerçekten UNIX zaman damgalarını kullanmanız gerekiyorsa, aşağıda ayrıntıları verilen tuzakların çoğunu önlemek için saat dilimini GMT olarak ayarlayın .

Uzun cevap: neden 24 * 60 * 60'a (aka 86400) bölmek güvensizdir

UNIX zaman damgalarını (ve bunu günlere dönüştürmek için 86400) kullanan cevapların çoğu, bir araya getirildiğinde, yanlış sonuçlara sahip senaryolara ve takip edilmesi zor olabilecek ve günler, haftalar veya aylar sonra bile ortaya çıkabilen ince hatalara yol açabilecek iki varsayım yapar. başarılı bir dağıtım. Çözüm işe yaramıyor - değil. Bugün. Ama yarın çalışmayı durdurabilir.

İlk hata, "dünden beri kaç gün geçti?" Sorusu sorulduğunda, bir günün bir günden daha kısa bir süre içinde "dün" ile belirtilen an ile şimdiki zaman arasında bir bilgisayarın gerçek olarak sıfıra cevap verebileceğini düşünmüyor .

Genellikle bir "günü" UNIX zaman damgasına dönüştürürken elde edilen, o günün gece yarısı için zaman damgasıdır .

Böylece 1 Ekim ile 15 Ekim arasında gece yarısı arasında on beş gün geçti. Ancak, 1 Ekim 13:00 ile 15 Ekim 14:55 arasında, on beş gün eksi 5 dakika geçti ve floor()örtük tamsayı dönüşümü kullanan ya da kullanan çoğu çözüm beklenenden bir gün daha az rapor edecek .

Peki "kaç gün önce Ymd H: i: s" idi? yanlış cevap verecektir .

İkinci hata bir günü 86400 saniyeye eşitlemektir. Bu neredeyse her zaman doğrudur - yapmadığı zamanları göz ardı etmek yeterince sık görülür. Ancak, gün ışığından yararlanma saati devreye girdiğinde , birbirini takip eden iki gece yarısı arasındaki saniye cinsinden mesafe kesinlikle en az 86400 değildir. Bir DST sınırı boyunca iki tarihi karşılaştırmak yanlış cevap verecektir.

Bu nedenle, tüm tarih zaman damgalarını sabit bir saate zorlamanın "hilesini" kullansanız bile, gece yarısını söyleyin (bu aynı zamanda, yalnızca gün-ay-yılını ve saat-dakika-saniye belirtmediğinizde çeşitli diller ve çerçeveler tarafından örtülü olarak yapılır; MySQL gibi veritabanlarında DATE türü ile aynı olur), yaygın olarak kullanılan formül

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

veya

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

DATE1 ve DATE2 yılın aynı DST segmentindeyken, 17'ye dönecektir; ancak 17.042 ve daha da kötüsü 16.958. Kullanımı katında () sonra olması gereken dönüştürür veya tamsayıya herhangi örtük bir kesilmeye diğer durumlarda bir 16 bir 17 gibi ifadeler "$ günlerde> 17" dönecektir truebu ifade etse bile 17.042 için o geçen gün sayma 18.

Ve bu kod platformlar arasında taşınabilir olmadığı için işler daha da büyür , çünkü bazıları sıçrama saniye uygulayabilir ve bazıları olmayabilir . Bu platformlarda yapmak , iki tarih arasındaki fark 86400 ancak 86.401, ya da belki 86399. olmayacak Yani 12,99999 gün 12 gün yerine 13 İki tarihleri göz önüne alındığında önümüzdeki Haziran kıracak bütün testleri Mayıs ayında çalıştı ve aslında geçti kodu 2015'te çalışan 2017'de çalışmaz - aynı tarihler ve hiçbir yıl artık bir yıl değildir. Ancak 2018-03-01 ve 2017-03-01 arasında, bu platformlarda , 365 yerine 366 gün geçecek ve 2018'i bir sıçrama yılı olacak (ki bu değil).

Yani gerçekten UNIX zaman damgalarını kullanmak istiyorsanız:

• round()işlevi akıllıca kullanın , değil floor().

• alternatif olarak, D1-M1-YYY1 ve D2-M2-YYY2 arasındaki farkları hesaplamayın. Bu tarihler gerçekten D1-M1-YYY1 00:00:00 ve D2-M2-YYY2 00:00:00 olarak kabul edilecektir. Bunun yerine, D1-M1-YYY1 22:30:00 ve D2-M2-YYY2 04:30:00 arasında dönüştürme. Her zaman yaklaşık yirmi saatlik bir süre kalırsınız. Bu yirmi bir saat veya on dokuz ve belki on sekiz saat, elli dokuz dakika otuz altı saniye olabilir. Önemli değil. Bu bir olan büyük marjı orada kalmak ve yakın gelecekte olumlu kalacak. Şimdi sen bunu kesecek floor()güvenlik içinde.

Doğru sihirli sabitleri, yuvarlama kludges ve bakım borcu önlemek için olsa çözüm olmaktır

• bir zaman kütüphanesi kullanın (Tarih, Karbon, her neyse); kendininkini yapma

• yazma kapsamlı test durumları artık saniye boyunca, artık yıllarda genelinde, DST sınırları ötesinde, vb yanı sıra sıradan tarihleri - gerçekten kötü tarih seçenekleri kullanarak. İdeal olarak (datetime çağrıları hızlıdır !) , Dizelerden sırayla toplanarak dört tam yıl (ve bir gün) değerinde tarih oluşturur ve ilk gün ile test edilen gün arasındaki farkın birer birer artmasını sağlar. Bu, düşük seviyeli rutinlerde ve artık saniye düzeltmelerinde herhangi bir değişiklik olursa tahribat yaratmaya çalışır, en azından bileceksiniz .

• bu testleri test paketinin geri kalanıyla düzenli olarak yapın. Milisaniye meselesidir ve sizi kelimenin tam anlamıyla saatlerce kafa çizilmesinden kurtarabilir .

Çözümünüz ne olursa olsun test edin!

Aşağıdaki fonksiyon funcdiff, gerçek dünya senaryosunda çözümlerden birini (olduğu gibi, kabul edileni) uygular.

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

Sonuç,

This function failed 280 of its 14603 tests

Korku Hikayesi: "zaman kazanmanın" maliyeti

Bu aslında birkaç ay önce oldu. Ustaca bir programcı, birkaç yerde meşhur "(MidnightOfDateB-MidnightOfDateA) / 86400" kodunu takarak en fazla yaklaşık otuz saniye süren bir hesaplamadan birkaç mikrosaniye tasarruf etmeye karar verdi. O kadar açıktı ki, bunu bile belgelememişti ve optimizasyon, entegrasyon testlerini geçti ve birkaç ay boyunca kodda gizlendi, hepsi fark edilmedi.

Bu, en çok satan satıcıların ücretlerini hesaplayan bir programda gerçekleşti, bunların en azı, birlikte alçakgönüllü beş kişilik bir programcı ekibinden daha korkunç bir şekilde daha fazla nüfuz sahibi. Bir ay birkaç ay önce, çok önemli olmayan nedenlerden dolayı, böcek çarptı - ve bu adamlardan bazıları bir gün boyunca yağ komisyonları değiştirdi. Onlar kesinlikle edildi değildir eğlendirdi.

Sonsuz kötüsü, (zaten çok az) iman onlar programda vardı kaybetti değildir ve - gizlice onları şafta tasarlanmıştır ve davrandı ediliyor elde - test durumlarda ile tam, ayrıntılı kod incelemesi koştu ve anlayabileceği şekilde yorumladı (artı bir sürü Önümüzdeki haftalarda kırmızı halı muamelesi).

Ne diyebilirim: artı tarafta, çok fazla teknik borçtan kurtulduk ve sallanan 90'larda bir COBOL istilasına geri dönen birkaç spagetti karışıklığını yeniden yazabildik ve yeniden düzenleyebildik. Program şüphesiz daha iyi çalışıyor ve bir şey balık gibi göründüğünde çabucak sıfırlanacak çok daha fazla hata ayıklama bilgisi var. Sadece bu son tek şeyin öngörülebilir gelecek için ayda bir veya iki adam-gün tasarruf edeceğini tahmin ediyorum.

Eksi tarafta, tüm brouhaha şirkete yaklaşık 200.000 €, artı yüz, artı şüphesiz bazı pazarlık gücüne (ve dolayısıyla daha fazla paraya) mal oldu.

"Optimizasyon" dan sorumlu adam bir yıl önce felaketten önce iş değiştirmişti, ama yine de ona zarar için dava açmak için konuşma vardı. Üst kademelerle "son adamın hatası" olduğu pek de iyi gitmedi - konuyu temizlemek için bir düzene benziyordu ve sonunda hala köpek kulübesindeyiz ve takımlardan biri bırakmayı planlıyor.

Yüzde doksan dokuz kez "86400 hack" kusursuz bir şekilde çalışacaktır. (Örneğin PHP'de, strtotime()DST'yi görmezden gelecek ve Ekim ayının son Cumartesi ve ertesi Pazartesi geceleri arasında tam olarak doğru olmasa bile tam olarak 2 * 24 * 60 * 60 saniye geçtiğini bildirecek ... ve iki yanlış mutlu bir şekilde doğru yapar).

Bu bayanlar ve baylar, yapmadığı zaman bir örnekti. Hava yastıkları ve emniyet kemerlerinde olduğu gibi, veya ' nin karmaşıklığına (ve kullanım kolaylığına) asla gerçekten ihtiyacınız olmayacaktır . Ama yapabileceğiniz gün (ya da bunu düşündüğünüzü kanıtlamanız gereken gün ) gece hırsız olarak gelecek. Hazır ol.DateTimeCarbon

Date_diff kullanımı kolay

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

• Daha fazla bilgi için: http://blog.innovsystems.com/php/get-number-days-between-two-dates-php

Nesneye yönelik stil:

$datetime1 = new DateTime('2009-10-11');
$datetime2 = new DateTime('2009-10-13');
$interval = $datetime1->diff($datetime2);
echo $interval->format('%R%a days');

Usul tarzı:

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

Bunu kullan :)

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

Şimdi çalışıyor

Seçilen cevap en doğru cevap değildir çünkü UTC dışında başarısız olacaktır. Saat dilimine ( listeye ) bağlı olarak, 24 saat olmadan "günler" yaratan zaman ayarlamaları olabilir ve bu hesaplamayı (60 * 60 * 24) başarısız yapar.

İşte bunun bir örneği:

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

Yani doğru çözüm DateTime kullanıyor olacak

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

İki tarih arasındaki farkı hesaplayın:

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

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

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

Çıktı: +272 gün

Date_diff () işlevi, iki DateTime nesnesi arasındaki farkı döndürür.

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

Bu ve benzeri amaçlar için besteci projelerimde Carbon kullanıyorum .

Bu kadar kolay olurdu:

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

Tarihleri ​​kolayca bulabilirsiniz

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

ve gerekirse:

$datediff=abs($datediff);

Saniye cinsinden zamanınız varsa (IE unix zaman damgası), zamanları çıkarabilir ve 86400'e (günde saniye) bölebilirsiniz.

PHP'de iki tarih arasındaki gün sayısı

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

Aşağıdaki kodu deneyebilirsiniz:

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

Başlangıç ​​ve bitiş tarihi arasındaki tüm günleri yankılamak istiyorsanız, bununla geldim:

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

İki tarih arasındaki gün farkını bulmanın en kolay yolu

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

Burada, 2. parametre geçilirse 1 Yıl 2 Ay 25 gün gösteren gelişmiş sürümüm.

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

Yukarıdaki kodu çok basit kullandı. Teşekkürler.

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

Bu basit işlevi kullanarak. Bildirme işlevi

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

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

ve bu işlevi istediğiniz gibi şöyle adlandırın

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

MySql kullanıyorsanız

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;

}

Karbon kullanmayı deneyin

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

Ayrıca kullanabilirsiniz

\Carbon\Carbon::parse('')

verilen zaman damgası dizesini kullanarak bir Karbon tarihi nesnesi oluşturmak için.

Tüm cevaplara baktığımda, tüm PHP sürümlerinde çalışan evrensel işlevi oluşturuyorum.

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;

Genel olarak, 2 tarih arasındaki günleri bulmak için 'DateTime' kullanıyorum. Ancak bazı nedenlerden dolayı, bazı sunucu kurulumlarında 'DateTime' etkin değilse, 'strtotime ()' ile basit (ancak güvenli değil) hesaplamayı kullanır.