Tarih ve Zaman

Bu konuda yeni bir gömülmüş obje olan Date anlatılacaktır. Bu obje tarihi ve saati tutar ve tarih/saat yönetimini üstlenir.

Örneğin, bu objeyi sadece saati saklama, modifiye etme için kullanabilirsiniz, veya zaman ölçümü için veya o anki zamanı göstermek için

Yaratma

Yeni bir Date objesi yaratmak için new Date() aÅŸağıdaki argümanların biri ile çaÄŸrılabilir.

new Date()

Argümansız – yeni o anki tarih ve saat ile yeni bir Date objesi oluÅŸturur:

let now = new Date();
alert( now ); // o anki tarih/saati gösterir.

new Date(milisaniye)

1 Ocak 1970 UCT+0’dan sonra geçen milisaniye(1/1000) ile tarih oluşturulmasıdır

// `0`  01.01.1970 UTC+0 demektir.
let Jan01_1970 = new Date(0);
alert( Jan01_1970 );

// Buna 24 saat eklemek için, get 02.01.1970 UTC+0
let Jan02_1970 = new Date(24 * 3600 * 1000);
alert( Jan02_1970 );

1 ocak 1970’den buyana geçen milisaniyeye timestamp ( zaman damgası ) denir.

Bu tarihin en basit biçimde gösterimidir. Her türlü bu zaman damgasından yeni bir tarih oluÅŸturmak mümkündür. Veya yine herhangi bir tarihten bu zaman damgasını date.getTime() ile almak mümkündür.

new Date(tarih_metni)

EÄŸer bir argüman var ve bu da karakter dizisi ise, Date.parse algoritmasına göre bakılır ve uygunsa tarih oluÅŸturulur.

let date = new Date("2017-01-26");
alert(date); // Thu Jan 26 2017 ...

new Date(yıl, ay, gün, saat, dakika, saniye, milisaniye)

Yerel zamanda Date objesi oluÅŸturmak için sadece ilk iki argüman zorunludur.

Not:

• yıl 4 basamaktan oluÅŸmalıdır. 2013 olur, 98 olmaz.
• ay sıfırdan baÅŸlar. Yani 0 Ocak, 11 Aralıktır.
• gün parametresi girilmez ise 1 olarak kabul edilir.
• saat/dakika/saniye/milisaniye deÄŸerleri girilmez ise 0 olarak kabul edilir.

Örneğin:

new Date(2011, 0, 1, 0, 0, 0, 0); // // 1 Jan 2011, 00:00:00
new Date(2011, 0, 1); // Diğer değerler veirlmediği halde yine aynı sonuç alınacaktır.

En düşün hassasiyet 1ms’dir(1/1000)

let date = new Date(2011, 0, 1, 2, 3, 4, 567);
alert( date ); // 1.01.2011, 02:03:04.567

Tarih bileÅŸenlerine eriÅŸim

Date objesinde yıla, aya vs. eriÅŸim için birçok metod bulunmaktadır. Fakat bunlar kaegorilere ayrılırsa hatırlanması daha kolay olacaktır.

getFullYear()

Yılı döner (4 basamaklı)

getMonth()

Ayı döner, 0-11 arasında.

getDate()

Ayın gününü döner, 1-31 arasındadır. İsmi aklınızı karıştırabilir.

getHours(), getMinutes(), getSeconds(), getMilliseconds()

Sırası ile saat, dakika, saniye ve milisaniye bilgilerini döner.

Bunlara ek olarak haftanın hangi günü olduğu bilgisi de alınabilir:

getDay()

Haftanın gününü, Pazar 0 , Pazartesi 6 olacak ÅŸekilde alır. Ä°lk gün her zaman pazardır. Bazı ülkelerde pazar resmi olarak ilk gün olmasa bile bu fonksiyon pazarı yine de ilk gün olarak alır.

Yukarıdaki tüm metodlar değerlerini yerel saate göre dönerler.

Bunun uluslararası saat için eÅŸleri mevcuttur(UTC). Bu metodlar gün, ay, yıl vs deÄŸerlerini UTC+0’a göre dönerler: There are also their UTC-counterparts, that return day, month, year and so on for the time zone UTC+0: getUTCFullYear(),getUTCMonth(), getUTCDay(). "get"'ten sonra "UTC" ekleyerek metodlara ulaÅŸmak mümkündür.

EÄŸer bulunduÄŸunuz saat dilimi UTC+0 dan farklıysa getHours() ve getUTCHours() arasında bir farklılık olacaktır.

// o anki yerel tarih
let date = new Date();

// yerel saat
alert( date.getHours() );

// UTC+0'daki yerel saat( Londra kış saati)
alert( date.getUTCHours() );

Belirtilen metodlar dışında, UTC tipi olmayan iki tane özel metod bulunmaktadır:

getTime()

Verilen tarihin zaman damgasını ( timestamp ) döndürür – 1 Ocak 1970 UTC+0’dan itibaren geçen milisaniye

getTimezoneOffset()

Yerel zaman ile UTC arasındaki farkı dakika olarak döndürür:

// Eğer UTC-1'de yaşıyorsanız, çıktısı 60
// Eğer UTC+3'de yaşıyorsanız, çıktısı -180
alert( new Date().getTimezoneOffset() );

Tarih bileÅŸeninin ayarlama

Aşağıdaki metodlar tarih bileşenlerini ayarlamaya yarar:

• setFullYear(year [, month, date])
• setMonth(month [, date])
• setDate(date)
• setHours(hour [, min, sec, ms])
• setMinutes(min [, sec, ms])
• setSeconds(sec [, ms])
• setMilliseconds(ms)
• setTime(milliseconds) (sets the whole date by milliseconds since 01.01.1970 UTC)

setTime() haricinde hepsinin UTC tipi de vardır, örneÄŸin: setUTCHours()

Gördüğünüz gibi,setHours gibi bazı metodlar birden fazla bileÅŸeni aynı anda ayarlamaya yarar. Bahsi geçmeyen bileÅŸenlerde bir deÄŸiÅŸiklik yapılmaz.

Örneğin:

let today = new Date();

today.setHours(0);
alert(today); // bugün ve saat 0

today.setHours(0, 0, 0, 0);
alert(today); // bugün ve saniye 00:00:00.

Otomatik Düzenleme

Otomatik düzenleme Date objesinin oldukça kullanışlı bir özelliÄŸidir. Tarihi sınırın dışında ayarladığınız durumlarda otomatik olarak kendini düzeltebilir.

Örneğin:

let date = new Date(2013, 0, 32); // 32 Ocak 2013 ?!?
alert(date); // ...is 1st Åžubat 2013!

Sınırın dışındaki tarih bileÅŸenleri otomatik olarak dağıtılır. Ayların sınırlarını düşünmenize gerek yoktur. Bunlar Date objesi tarafından otomatik olarak hesaplanacaktır.

Diyelim ki “28 Åžub 2016”'yı iki gün artırmak istediniz. Belki “2 Mart” belki de “1 Mart” olabilir. Bunu bizim düşünmemize gerek yoktur. Sadece iki gün ekleyin yeterli. Date objesi geri kalanı sizin için yapacaktır:

let date = new Date(2016, 1, 28);
date.setDate(date.getDate() + 2);

alert( date ); // 1 Mar 2016

Bu özellik belirtilen bir süre sonrasında tekrardan tarihi almak için kullanılır. Örneğin “Şu andan 70 sn sonrası”'ni al.

let date = new Date();
date.setSeconds(tarih.getSeconds() + 70);

alert( date ); // doğru tarihi gösterir.

Sıfır veya negatif değer de ayarlamak mümkündür. Örneğin:

let date = new Date(2016, 0, 2); // 2 Ocak 2016

date.setDate(1); // ayın 1. günü
alert( date );

date.setDate(0); // İlk gün 1 olduğundan dolayı 0 geçen ayın son gününü verir. min day is 1, so the last day of the previous month is assumed
alert( date ); // 31 Aralık 2015

Tarihten sayıya, tarih farklılığı

Date objesi sayıya çevrildiÄŸinde, aynı timestamp’te olduÄŸu gibi date.getTime() deÄŸerini alır:

let date = new Date();
alert(+date); // date.getTime() ile aynı şekilde milisaniye döner.

Önemli not: tarihler birbirinden çıkarılabilir fakat sonuç ms cinsinden olur.

Bu iki tarih arasındaki zamanı ölçmek için kullanılabilir:

let start = new Date(); // saymaya baÅŸla!

// iÅŸi yap
for (let i = 0; i < 100000; i++) {
  let doSomething = i * i * i;
}

let end = new Date(); // bitt

alert( `Döngü ${end - start} ms` );

Date.now()

EÄŸer sadece zaman farkını ölçmek istiyorsanız, Date objesine ihtiyacınız yok.

Bunun için Date.now() adında bir obje bulunmakta.

Mantık olarak new Date().getTime() ile aynı olmasına raÄŸmen yeni bir Date objesi oluÅŸturmamaktadır. Bundan dolayı çok hızlı ve garbage collection’a yük bindirmemiÅŸ olur.

Genelde kullanışlı olduğundan veya performans özel JavaScript oyunları gibi uygulamalarda kullanılır.

Aşağıdaki daha iyidir denebilir:

let start = Date.now(); // 1 Ocak 1970'den şimdiye kadar olan zamanın ms cinsinden değeri

// iÅŸi yap
for (let i = 0; i < 100000; i++) {
  let doSomething = i * i * i;
}

let end = Date.now(); // done

alert( `Döngü ${end - start} ms sürdür` ); // sadece sayılar çıkarıldı tarihler değil.

Kıyaslama

Eğer çok ağır yüklü işlemler için kıyaslama yapılıyorsa, dikkatli olunmalıdır.

Örneğin, iki tarih arasındaki farkı hesaplayan iki fonksiyondan hangisinin daha hızlı olduğunu inceleyelim

// tarih1 ve tarih2, hangisi işlemi daha hızlı tamamlar.
function diffSubtract(date1, date2) {
  return date2 - date1;
}

// veya
function diffGetTime(date1, date2) {
  return date2.getTime() - date1.getTime();
}

Yukarıdaki iki fonksiyon aynı iÅŸlemi yapar, fakat bir tanesi date.getTime() ile o tarihin ms cinsinden deÄŸerini alırken diÄŸeri tarihin sayıya doÄŸrudan çevrilmesine dayalı. Sonuçları her zaman aynı olacaktır.

Öyleyse hangisi daha hızlı?

Bunu ölçmek için fonksiyonları birçok defa çalıştırıp aradaki farkı öyle kontrol etmektir.

Ölçülecek olursa:

function diffSubtract(date1, date2) {
  return date2 - date1;
}

function diffGetTime(date1, date2) {
  return date2.getTime() - date1.getTime();
}

function bench(f) {
  let date1 = new Date(0);
  let date2 = new Date();

  let start = Date.now();
  for (let i = 0; i < 100000; i++) f(date1, date2);
  return Date.now() - start;
}

alert( 'Time of diffSubtract: ' + bench(diffSubtract) + 'ms' );
alert( 'Time of diffGetTime: ' + bench(diffGetTime) + 'ms' );

Vay be! getTime() ile yapılan iÅŸlem çok daha hızlı! Bunun nedeni tip dönüşümü olmaması, böylece JavaScript motoru çok daha iyi optimize edebilmektedir.

Bir değer aldık fakat bu henüz iyi bir karşılaştırma olmadı.

Diyelim ki karsilastirma(cikarma) çalışırken iÅŸlemci paralelde baÅŸka bir ÅŸeyler ile uÄŸraşıyor olsun. Bu uÄŸraÅŸtığı iÅŸlemler karsilastirma(tarihFarki) zamanında bitsin.

Bu aslında oldukça gerçekçi bir senaryodur.

A pretty real scenario for a modern multi-process OS.

Sonuç olarak karsilastirma(cikarma) için daha az iÅŸlemci kaynağı kullanılanılır ve bu da yanlış sonuca neden olur.

Daha güvenilir karşılaştırma yapabilmek için bu karşılaştırma paketi bir kaç defa çalıştırılmalıdır

Aşağıda örneğini görebilirsiniz:

function diffSubtract(date1, date2) {
  return date2 - date1;
}

function diffGetTime(date1, date2) {
  return date2.getTime() - date1.getTime();
}

function bench(f) {
  let date1 = new Date(0);
  let date2 = new Date();

  let start = Date.now();
  for (let i = 0; i < 100000; i++) f(date1, date2);
  return Date.now() - start;
}

let time1 = 0;
let time2 = 0;

// Paketi 10 defa çalışacak şekilde ayarlayın
for (let i = 0; i < 10; i++) {
  time1 += bench(diffSubtract);
  time2 += bench(diffGetTime);
}

alert( 'Total time for diffSubtract: ' + time1 );
alert( 'Total time for diffGetTime: ' + time2 );

Modern JavaScript motorları “sıcak kod” için daha gelişmiş optimizasyon yapmaya başladılar. Bu nadiren çalışan kodlar yerine daha çok fazlaca tekrar eden kodların optimizasyonu anlamına gelmektedir. Böylece ilk çalışmalar çok ta optimize edilmezler.

// ana döngüye girmeden ısınma turu:
bench(diffSubtract);
bench(diffGetTime);

// şimdi ise karşılaştırma ( benchmark )
for (let i = 0; i < 10; i++) {
  time1 += bench(diffSubtract);
  time2 += bench(diffGetTime);
}

Karakter dizisinden Date.parse ile tarih alma.

Date.parse(str) metodu karakterden tarih ayrıştırmaya yarar.

Metin formatı: YYYY-MM-DDTHH:mm:ss.sssZ ÅŸeklindedir, burada :

• YYYY-MM-DD – tarih : yıl-ay-gün
• "T" karakteri ayraç.
• HH:mm:ss.sss – zaman: saat:dakika:saniye.sarise ÅŸeklindedir.
• Ä°steÄŸe baÄŸlı olarak eklenen 'Z' +-hh:mm ÅŸeklinde UTC’ye göre zaman ayarlamaya yarar. Varsayılan Z deÄŸeri UTC+0 anlamına gelir.

Daha kısa YYYY-MM-DD veya YYYY-MM hatta YYYY gibi ÅŸeklinde bile olabilir.

Date.parse(str) çaÄŸrısı verilen formatta karakterleri alır ve timestamp( 1 Ocak 1970 UTC+0’dan itibaren geçen sarise ) olarak geri döner. EÄŸer format doÄŸru deÄŸilse, NaN döner.

Örneğin:

let ms = Date.parse('2012-01-26T13:51:50.417-07:00');

alert(ms); // 1327611110417  (timestamp)

Zaman damgasından (timestamp) new Date objesi yaratılabilir.

let date = new Date( Date.parse('2012-01-26T13:51:50.417-07:00') );

alert(date);

Özet

• Tarih ve saat bilgisi JavaScript’te Date objesiyle temsil edilir. Sadece tarih veya saadece saat bilgisiyle obje oluÅŸturulamaz: Date objesi her zaman iki bilgiyi de taşır.
• Aylar 0’dan baÅŸlar. (Evet, Ocak ayı 0. aydır)
• Haftanın günü getDate() de 0’dan baÅŸlar (Pazar günü)
• Date objesi eÄŸer belirttiÄŸiniz tarih mevcut deÄŸilse bunu hesaplayabilir. Bu; gün, saat, ay ekleme/çıkarmak için kullanışlı bir özelliktir.
• Tarihler çıkartılabilir, aradaki fark sarise olarak döndürülür. Bunun nedeni Date sayıya çevrildiÄŸinde zaman damgası olur.
• O anki zaman damgasını (timestamp) almak için Date.now() kullanabilirsiniz.

Diğer sistemlerin aksine, zaman damgası javascripte saniye değil sarise cinsindendir.

Eğer daha ayrıntılı zaman bilgisine erişmek istiyorsanız. JavaScript desteklemese bile çoğu sistem microsaniyeye destek verir ( saniyenin milyonda biri ). Örneğin performance.now() sayfanın yüklenme süresini mikrosaniye cinsinden verir.

alert(`Loading started ${performance.now()}ms ago`);
// Sonuç : Yüklemeye 4731.26000000001ms önce başladı
// .26 mikrosaniye (260 mikrosaniye)
// noktanın 3. basamağından sonraki değerler sapmadır fakat ilk 3 basamak doğrudur.

Node.JS microtime modülüne sahiptir. Teknik olarak her cihaz daha hassas tarih bilgisine ulaÅŸabilir, sadece Date objesinde bu bilgiler yer almaz.