Bu materyal This madde henüz sadece: English, 日本語, 한국어, Русский dillerinde mevcuttur. Lütfen bize bu bölümün çevirisini Türkçe çevirmek için yardım ediniz.

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 simdi = new Date();
alert( simdi ); // 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 tarih = new Date("2017-01-26");
alert(tarih); // 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 tarih = new Date(2011, 0, 1, 2, 3, 4, 567);
alert( tarih ); // 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.
getYear() değil getFullYear()

Çoğu JavaScript motoru standart olmayan getYear() metodunu entegre etmişlerdir. Bu metod kullanımdan kaldırılmıştır. Bazen iki basamaklı yılı dönerler. Bu metodu kullanmayın!. Bunun yerine getFullYear() metodunu kullanabilirsiniz.

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:

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 bugun = new Date();

bugun.setHours(0);
alert(bugun); // bu gün ve saat 0

bugun.setHours(0, 0, 0, 0);
alert(today); // bu gü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 tarih = new Date(2013, 0, 32); // 32 Ocak 2013 ?!?
alert(tarih); // ...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 tarih = new Date(2016, 1, 28);
tarih.setDate(date.getDate() + 2);

alert( tarih ); // 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 tarih = new Date();
tarih.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 tarih = new Date(2016, 0, 2); // 2 Ocak 2016

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

tarih.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 tarih = new Date();
alert(+tarih); // 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 baslangic = new Date(); // saymaya başla!

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

let bitis = new Date(); // bitt

alert( `Döngü ${bitis - baslangic} 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 baslangic = 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 bitis = Date.now(); // done

alert( `Döngü ${bitis - baslangic} 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 cikarma(tarih1, tarih2) {
  return tarih2 - tarih1;
}

// veya
function tarihFarki(tarih1, tarih2) {
  return tarih2.getTime() - tarih1.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 cikarma(tarih1, tarih2) {
  return tarih2 - tarih1;
}

function tarihFarki(tarih1, tarih2) {
  return tarih2.getTime() - tarih1.getTime();
}

function karsilastirma(f) {
  let tarih1 = new Date(0);
  let tarih2 = new Date();

  let baslangic = Date.now();
  for (let i = 0; i < 100000; i++) f(tarih1, tarih2);
  return Date.now() - baslangic;
}

alert( 'Çıkarma işlemi ile: ' + karsilastirma(cikarma) + 'ms' );
alert( 'tarihFarki islemi ile: ' + karsilastirma(tarihFarki) + 'ms' );

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 kikarsilastirma(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 karsilastirm(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 cikarma(tarih1, tarih2) {
  return tarih2 - tarih1;
}

function tarihFarki(tarih1, tarih2) {
  return tarih2.getTime() - tarih1.getTime();
}

function karsilastirma(f) {
  let tarih1 = new Date(0);
  let tarih2 = new Date();

  let baslangic = Date.now();
  for (let i = 0; i < 100000; i++) f(tarih1, tarih2);
  return Date.now() - baslangic;
}

let zaman1 = 0;
let zaman2 = 0;

// Paketi 10 defa çalışacak şekilde ayarlayın
for (let i = 0; i < 10; i++) {
  zaman1 += karsilastirma(cikarma);
  zaman2 += karsilastirma(tarihFarki);
}

alert( 'Cikarma islemi ile geçen süre: ' + zaman1 );
alert( 'TarihFarki islemi ile geçen süre: ' + zaman2 );

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:
karsilastirma(cikarma);
karsilastirma(tarihFarki);

// şimdi ise karşılaştırma ( benchmark )
for (let i = 0; i < 10; i++) {
  zaman1 += karsilastirma(cikarma);
  zaman2 += karsilastirma(tarihFarki);
}
Mikro seviyede karşılaştırma yaparken daha dikkatli olunmalıdır.

Modern JavaScript motorları kod üzerinde birçok iyileştirme yaparlar. Normal kullanımdan ziyade yapay test sonuçları üzerinde değişikliklere neden olabilirler. Özellikle çok küçük karşılaştırmalarda. Bundan dolayı eğer performan sizin için çok ciddi bir konu ise, JavaScript motorlarının nasıl çalıştığını öğrenmeniz gerekmektedir. Öğrendiğinizde mikro seviyede bir karşılaştırmaya ihtiyacınız kalmayacaktır.

V8 motoru ile ilgili makaleleri http://mrale.ph adresinden bulabilirsiniz.

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 tarih = new Date( Date.parse('2012-01-26T13:51:50.417-07:00') );

alert(tarih);

Ö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(`Yüklemeye 4731.26000000001ms önce başladı`);
// 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.

Görevler

önem: 5

Yerel saat diliminde Feb 20, 2012, 3:12am için bir Date objesi oluşturun.

alert ile ekrana basın.

new Date varsayılanda local zamaı kullnır. Burada hatırlanması gereken tek şey ayların 0’dan başladığıdır.

Bundan dolay February( Şubat )'ın indeksi 1’dir.

let d = new Date(2012, 1, 20, 3, 12);
alert( d );
önem: 5

haftaninGunleriniAl(tarih) adında bir fonksiyon yazın ve bu fonksiyon günlerin kısa formatlarını dönsün : ‘PT’, ‘SA’, ‘ÇA’, ‘PR’, ‘CM’, ‘CT’, ‘PZ’ gibi.

Örneğin:

let tarih = new Date(2012, 0, 3);  // 3 Jan 2012
alert( haftaninGunleriniAl(date) );        //  "SA" dönmesi gerekiyor.

Testler ile korunaklı olan aç.

date.getDay() pazardan başlayarak haftanın günlerini dönmektedir.

Eğer günler için bir dizi yapılırsa bu diziye göre günü dönmek mümkün olur:

function haftaninGunleriniAl(date) {
  let gunler = ['PT', 'SA', 'ÇA', 'PR', 'CM', 'CT', 'PZ' ];

  return gunler[tarih.getDay()];
}

let tarih = new Date(2014, 0, 3); // 3 Jan 2014
alert( haftaninGunleriniAl(tarih) ); // CM

Çözümü testler korunaklı alanda olacak şekilde aç.

önem: 5

Avrupa devletlerinde hafta pazartesinden başlar ( pazartesi 1, salı 2, pazar 7 gibi ). yerelGunAl(tarih) adında bir fonksiyon yazın ve bu fonksiyon tarih objesinin haftanın hangi gününe denk geldiğini dönsün.

let tarih = new Date(2012, 0, 3);  // 3 Ocak 2012
alert( yerelGunAl(tarih) );       // salı,2 dönmeli

Testler ile korunaklı olan aç.

function yerelGunAl(tarih) {

  let gun = tarih.getDay();

  if (gun == 0) { //0 -> 7 olmakta.
    gun = 7;
  }

  return gun;
}

alert( getLocalDay(new Date(2012, 0, 3)) ); // 2

Çözümü testler korunaklı alanda olacak şekilde aç.

önem: 4

kacGunOnce(tarih,gün) adında bir fonksiyon ile verilen tarih'ten gün kadar öncesini bulunuz.

Örneğin, eğer bu gün 20’si ise, kacGunOnce(new Date(),1) size 19 döndürmeli. Yine kacGunOnce(new Date(),2) size 18 döndermeli.

Should also work over months/years reliably:

let tarih = new Date(2015, 0, 2);

alert( kacGunOnce(tarih, 1) ); // 1, (1 Ocak 2015)
alert( kacGunOnce(tarih, 2) ); // 31, (31 Aralık 2014)
alert( kacGunOnce(tarih, 365) ); // 2, (2 Ocak 2014)

Not: Fonksiyon verilen tarih üzerinde oynama yapmamalıdır.

Testler ile korunaklı olan aç.

Yapacağımız işlem: verilen tarih'ten istenen gün kadar çıkarmaktır:

function kacGunOnce(tarih, gun) {
  tarih.setDate(tarih.getDate() - gun);
  return tarih.getDate();
}

… Fakat fonksiyon tarih'i değiştirmemelidir. Bu önemlidir çünkü dışarıdaki kod gönderilen tarihin aynı kaldığını varsaymaktadır.

Bunu uygulayabilmek için tarih objesinin klonunu almak mümkündür:

function kacGunOnce(tarih, gun) {
  let tarihKopyasi = new Date(tarih);

  tarihKopyasi.setDate(tarih.getDate() - gun);
  return tarihKopyasi.getDate();
}

let tarih = new Date(2015, 0, 2);

alert( kacGunOnce(tarih, 1) ); // 1, (1 Ocak 2015)
alert( kacGunOnce(tarih, 2) ); // 31, (31 Aralık 2014)
alert( kacGunOnce(tarih, 365) ); // 2, (2 Ocak 2014)

Çözümü testler korunaklı alanda olacak şekilde aç.

önem: 5

ayinSonGunu(yil,ay) adlı bir metod yazın ve bu metod ayın son gününün dönsün. Bazen bu 30, bazen 31 hatta 28/29 bile olabilir ( Şubat )

Parametreler:

  • yil – 4 basamaklı format ile yıl bilgisi.
  • ay – 0’dan başlayacak şekilde ayın indeksi.

Örneğin, ayinSonGunu(2012, 1) = 29 (artık yıldır).

Testler ile korunaklı olan aç.

Bir sonraki ayın bilgisiyle yeni bir tarih oluşturulduğunda:

function ayinSonGunu(yil, ay) {
  let tarih = new Date(yil, ay + 1, 0);
  return tarih.getDate();
}

alert( ayinSonGunu(2012, 0) ); // 31
alert( ayinSonGunu(2012, 1) ); // 29
alert( ayinSonGunu(2013, 1) ); // 28

Normalde tarihler 1’den başlıyor fakat biz istediğimiz sayıdan başlatabiliriz, tarih objesi bunu kendisine göre ayarlayacaktır. Öyleyse 0 gönderdiğimizde bu “ayın 1. gününden önceki günü göster” anlamına gelir. Bu da “bir önceki ayın son günü” demektir.

Çözümü testler korunaklı alanda olacak şekilde aç.

önem: 5

bugundenSaniye() adında bir fonksiyon yazın ve bu fonksiyon günün başlangıcından itibaren geçen saniyeyi dönsün.

Örneğin eğer şimdi 10:00 am ise ve gün ışığından yararlanılmıyor ise:

getSecondsToday() == 36000 // (3600 * 10)

Fonksiyon her gün çalışabilmelidir. Bu demek oluyor ki elle bu günün değerini almamalısınız.

Bu gün geçen zamanı alabilmek için bu günün 00:00:00’ı için bir tarih objesi oluşturup bunu şimdi'nin tarih objesinden çıkarabilirsiniz.

Bunun sonucu milisaniye cinsinden olacaktır, bundan dolayı dönen değeri 1000’e bölerseniz saniye alırsınız:

function bugundenSaniye() {
  let simdi = new Date();

 // o anki gün/ay/yıl'ı kullanarak yeni bir tarih objesi oluşturur.
 let bugun = new Date(simdi.getFullYear(), simdi.getMonth(), simdi.getDate());

  let fark = simdi - bugun; // ms cinsinden
  return Math.round(fark / 1000); // saniyeye çevrildi
}

alert( bugundenSaniye() );

Bunun alternativi, saat/dakika/saniye gibi bilgilerin saniyeye çevrilmesidir:

function bugundenSaniye() {
  let d = new Date();
  return d.getHours() * 3600 + d.getMinutes() * 60 + d.getSeconds();
};
önem: 5

yarinaKacSn() adında bir fonksiyon yazın ve bu fonksiyon yarına kaç saniye olduğunu dönsün.

Örneğin, eğer saat 23:00 ise :

yarinaKacSn() == 3600

Not: Fonksiyon her gün çalışabilmelidir. Bu demek oluyor ki elle bu günün değerini almamalısınız.

Yarına olan süreyi bulmak için “yarının 00:00:00”'ından şimdi arasındaki fark bulunur.

Önce “yarını” tanımlamak gereklidir:

function yarinaKacSn() {
  let simdi = new Date();

  // yarin
  let yarin = new Date(simdi.getFullYear(), simdi.getMonth(), simdi.getDate()+1);

  let fark = yarin - simdi; // ms cinsinden fark
  return Math.round(fark / 1000); // saniyeye cevir
}

Alternative solution:

function getSecondsToTomorrow() {
  let now = new Date();
  let hour = now.getHours();
  let minutes = now.getMinutes();
  let seconds = now.getSeconds();
  let totalSecondsToday = (hour * 60 + minutes) * 60 + seconds;
  let totalSecondsInADay = 86400;

  return totalSecondsInADay - totalSecondsToday;
}

Please note that many countries have Daylight Savings Time (DST), so there may be days with 23 or 25 hours. We may want to treat such days separately.

önem: 4

formatTarih(tarih) adında bir fonksiyon yazınız, bu tarih'i aşağıdaki gibi formatlamalıdır:

  • Eğer tarih 1 sn’den önce geçiyse "şimdi" yazmalıdır.
  • Eğer, eğer 1 dk önce geçtiyse "n. saniye önce" yazılmalıdır.
  • Eğer, bir saatten önce geçtiyse "m. dakika önce" yazılmalıdır.
  • Diğer türlü tüm tarihi "DD.MM.YY HH:mm" formatında yazmalıdır. Bu : "gun.ay.yıl saat:dakika" formatıdır. Örneğin : 31.12.16 10:00.

Örneğin:

alert( formatTarih(new Date(new Date - 1)) ); // "şimdi"

alert( formatTarih(new Date(new Date - 30 * 1000)) ); // "30 saniye önce"

alert( formatTarih(new Date(new Date - 5 * 60 * 1000)) ); // "5 dakika önce"

// dün için gün 31.12.2016, 20:00
alert( formatTarih(new Date(new Date - 86400 * 1000)) );

Testler ile korunaklı olan aç.

tarih'ten şimdiye kadar geçen süre – tarihleri birbirinden çıkar.

function formatTarih(tarih) {
  let fark = new Date() - tarih; // Farkın ms. cinsinden değeri

  if (fark < 1000) { // 1 saniye önce
    return 'Şimdi';
  }

  let sn = Math.floor(fark / 1000); // farkı saniyeye çevir.

  if (sn < 60) {
    return sn + ' saniye önce';
  }

  let dk = Math.floor(fark / 60000); // farkı dakika çevir
  if (dk < 60) {
    return dk + ' dakika önce';
  }

  // tarihi formatla
  // ve geri kalan tek basamakları iki basamak haline getir.
  let d = date;
  d = [
    '0' + d.getDate(),
    '0' + (d.getMonth() + 1),
    '' + d.getFullYear(),
    '0' + d.getHours(),
    '0' + d.getMinutes()
  ].map(component => component.slice(-2)); // Her bileşenin son iki hanesini al.

  // bileşenleri tarihe ekle
  return d.slice(0, 3).join('.') + ' ' + d.slice(3).join(':');
}

alert( formatTarih(new Date(new Date - 1)) ); // "Şimdi"

alert( formatTarih(new Date(new Date - 30 * 1000)) ); // "30 saniye önce"

alert( formatTarih(new Date(new Date - 5 * 60 * 1000)) ); // "5 dakika önce"

// dünün günü şu şekilde: 31.12.2016, 20:00
alert( formatTarih(new Date(new Date - 86400 * 1000)) );

Alternative solution:

function formatDate(date) {
  let dayOfMonth = date.getDate();
  let month = date.getMonth() + 1;
  let year = date.getFullYear();
  let hour = date.getHours();
  let minutes = date.getMinutes();
  let diffMs = new Date() - date;
  let diffSec = Math.round(diffMs / 1000);
  let diffMin = diffSec / 60;
  let diffHour = diffMin / 60;

  // formatting
  year = year.toString().slice(-2);
  month = month < 10 ? '0' + month : month;
  dayOfMonth = dayOfMonth < 10 ? '0' + dayOfMonth : dayOfMonth;

  if (diffSec < 1) {
    return 'right now';
  } else if (diffMin < 1) {
    return `${diffSec} sec. ago`
  } else if (diffHour < 1) {
    return `${diffMin} min. ago`
  } else {
    return `${dayOfMonth}.${month}.${year} ${hour}:${minutes}`
  }
}

Çözümü testler korunaklı alanda olacak şekilde aç.

Eğitim haritası

Yorumlar

yorum yapmadan önce lütfen okuyun...
  • Eğer geliştirme ile alakalı bir öneriniz var ise yorum yerine github konusu gönderiniz.
  • Eğer makalede bir yeri anlamadıysanız lütfen belirtiniz.
  • Koda birkaç satır eklemek için <code> kullanınız, birkaç satır eklemek için ise <pre> kullanın. Eğer 10 satırdan fazla kod ekleyecekseniz plnkr kullanabilirsiniz)