Tanggal dan waktu

Penulis：Eve Cole Waktu Pembaruan：2024-12-24 11:00:57

Mari kita temui objek bawaan baru: Tanggal. Ini menyimpan tanggal, waktu dan menyediakan metode untuk manajemen tanggal/waktu.

Misalnya, kita dapat menggunakannya untuk menyimpan waktu pembuatan/modifikasi, mengukur waktu, atau sekadar mencetak tanggal sekarang.

Penciptaan

Untuk membuat objek Date baru, panggil new Date() dengan salah satu argumen berikut:

new Date()

Tanpa argumen – buat objek Date untuk tanggal dan waktu saat ini:

 biarkan sekarang = Tanggal baru();
waspada( sekarang ); // menampilkan tanggal/waktu saat ini

new Date(milliseconds)
Buat objek Date dengan waktu yang sama dengan jumlah milidetik (1/1000 detik) yang berlalu setelah 1 Januari 1970 UTC+0.
```
 // 0 berarti 01.01.1970 UTC+0
biarkan Jan01_1970 = Tanggal baru(0);
peringatan( Jan01_1970 );

// sekarang tambahkan 24 jam, dapatkan 02.01.1970 UTC+0
biarkan Jan02_1970 = Tanggal baru(24*3600*1000);
peringatan( Jan02_1970 );
```
Bilangan bulat yang mewakili jumlah milidetik yang telah berlalu sejak awal tahun 1970 disebut stempel waktu .
Ini adalah representasi numerik ringan dari suatu tanggal. Kita selalu dapat membuat tanggal dari stempel waktu menggunakan new Date(timestamp) dan mengonversi objek Date yang ada menjadi stempel waktu menggunakan metode date.getTime() (lihat di bawah).
Tanggal sebelum 01.01.1970 memiliki stempel waktu negatif, misalnya:
```
 // 31 Des 1969
misalkan 31 Des_1969 = Tanggal baru (-24 * 3600 * 1000);
peringatan(31 Desember 1969 );
```
new Date(datestring)

Jika ada satu argumen, dan itu adalah string, maka argumen tersebut diuraikan secara otomatis. Algoritmenya sama dengan yang digunakan Date.parse , kita akan membahasnya nanti.

 biarkan tanggal = Tanggal baru("26-01-2017");
peringatan(tanggal);
// Waktunya belum ditentukan, jadi diasumsikan tengah malam GMT dan
// disesuaikan dengan zona waktu di mana kode dijalankan
// Jadi hasilnya bisa jadi
// Kam, 26 Jan 2017 11:00:00 GMT+1100 (Waktu Musim Panas Bagian Timur Australia)
// atau
// Rabu 25 Jan 2017 16:00:00 GMT-0800 (Waktu Standar Pasifik)

new Date(year, month, date, hours, minutes, seconds, ms)
Buat tanggal dengan komponen tertentu dalam zona waktu lokal. Hanya dua argumen pertama yang wajib.
- year harus terdiri dari 4 digit. Untuk kompatibilitas, 2 digit juga diterima dan dianggap 19xx , misalnya 98 sama dengan 1998 di sini, tetapi selalu menggunakan 4 digit sangat dianjurkan.
- Penghitungan month dimulai dari 0 (Jan), sampai dengan 11 (Des).
- Parameter date sebenarnya adalah hari dalam sebulan, jika tidak ada maka diasumsikan 1 .
- Jika hours/minutes/seconds/ms tidak ada, maka diasumsikan sama dengan 0 .
Misalnya:
```
 Tanggal baru(2011, 0, 1, 0, 0, 0, 0); // 1 Januari 2011, 00:00:00
Tanggal baru (2011, 0, 1); // sama, jam dll adalah 0 secara default
```
Presisi maksimal adalah 1 ms (1/1000 detik):
```
 biarkan tanggal = Tanggal baru(2011, 0, 1, 2, 3, 4, 567);
peringatan(tanggal); // 1.01.2011, 02:03:04.567
```

Akses komponen tanggal

Ada beberapa metode untuk mengakses tahun, bulan dan sebagainya dari objek Date :

dapatkanSetahun Penuh()
Dapatkan tahun (4 digit)
dapatkan Bulan()
Dapatkan bulannya, dari 0 hingga 11 .
dapatkanTanggal()
Dapatkan hari dalam sebulan, dari 1 hingga 31, nama metodenya memang terlihat agak aneh.
getHours(), getMinutes(), getSeconds(), getMilliseconds()
Dapatkan komponen waktu yang sesuai.

Bukan getYear() , tapi getFullYear()

Banyak mesin JavaScript menerapkan metode non-standar getYear() . Metode ini sudah tidak digunakan lagi. Terkadang ia mengembalikan 2 digit tahun. Tolong jangan pernah menggunakannya. Ada getFullYear() untuk tahun ini.

Selain itu, kita bisa mendapatkan hari dalam seminggu:

dapatkan hari()
Dapatkan hari dalam seminggu, dari 0 (Minggu) hingga 6 (Sabtu). Hari pertama selalu hari Minggu, di beberapa negara tidak demikian, namun tidak dapat diubah.

Semua metode di atas mengembalikan komponen relatif terhadap zona waktu lokal.

Ada juga rekanan UTC-nya, yang mengembalikan hari, bulan, tahun, dan seterusnya untuk zona waktu UTC+0: getUTCFullYear(), getUTCMonth(), getUTCDay(). Cukup masukkan "UTC" tepat setelah "get" .

Jika zona waktu lokal Anda digeser relatif terhadap UTC, maka kode di bawah ini menunjukkan jam yang berbeda:

 // tanggal sekarang
biarkan tanggal = Tanggal baru();

// jam di zona waktu Anda saat ini
peringatan(tanggal.getJam() );

// jam dalam zona waktu UTC+0 (waktu London tanpa musim panas)
peringatan(tanggal.getUTCHours() );

Selain metode yang diberikan, ada dua metode khusus yang tidak memiliki varian UTC:

dapatkanWaktu()
Mengembalikan stempel waktu untuk tanggal – beberapa milidetik berlalu sejak 1 Januari 1970 UTC+0.
dapatkanTimezoneOffset()

Mengembalikan perbedaan antara UTC dan zona waktu lokal, dalam hitungan menit:

 // jika Anda berada di zona waktu UTC-1, outputnya 60
// jika Anda berada di zona waktu UTC+3, output -180
peringatan( Tanggal baru().getTimezoneOffset() );

Menetapkan komponen tanggal

Metode berikut memungkinkan untuk mengatur komponen tanggal/waktu:

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) (menetapkan keseluruhan tanggal dalam milidetik sejak 01.01.1970 UTC)

Masing-masing kecuali setTime() memiliki varian UTC, misalnya: setUTCHours() .

Seperti yang bisa kita lihat, beberapa metode dapat menyetel beberapa komponen sekaligus, misalnya setHours . Komponen yang tidak disebutkan tidak diubah.

Misalnya:

 biarkan hari ini = Tanggal baru();

hari ini.setJam(0);
waspada (hari ini); // masih hari ini, tapi jamnya diubah menjadi 0

hari ini.setJam(0, 0, 0, 0);
waspada (hari ini); // masih hari ini, sekarang tepat pukul 00:00:00.

Koreksi otomatis

Koreksi otomatis adalah fitur yang sangat berguna pada objek Date . Kita dapat menetapkan nilai di luar rentang, dan nilai tersebut akan menyesuaikan secara otomatis.

Misalnya:

 biarkan tanggal = Tanggal baru(2013, 0, 32); // 32 Januari 2013?!?
peringatan(tanggal); // ...tanggal 1 Februari 2013!

Komponen tanggal di luar rentang didistribusikan secara otomatis.

Katakanlah kita perlu menambah tanggal “28 Feb 2016” sebanyak 2 hari. Bisa jadi “2 Mar” atau “1 Mar” jika terjadi tahun kabisat. Kita tidak perlu memikirkannya. Cukup tambahkan 2 hari. Objek Date akan melakukan sisanya:

 biarkan tanggal = Tanggal baru(2016, 1, 28);
tanggal.setDate(tanggal.getDate() + 2);

peringatan(tanggal); // 1 Maret 2016

Fitur tersebut sering digunakan untuk mendapatkan tanggal setelah jangka waktu tertentu. Misalnya, mari kita ambil tanggal “70 detik setelah sekarang”:

 biarkan tanggal = Tanggal baru();
tanggal.setSeconds(tanggal.getSeconds() + 70);

peringatan(tanggal); // menunjukkan tanggal yang benar

Kita juga dapat menetapkan nilai nol atau bahkan negatif. Misalnya:

 biarkan tanggal = Tanggal baru(2016, 0, 2); // 2 Januari 2016

tanggal.setDate(1); // tetapkan hari 1 bulan
peringatan(tanggal);

tanggal.setDate(0); // min hari adalah 1, jadi diasumsikan hari terakhir bulan sebelumnya
peringatan(tanggal); // 31 Des 2015

Tanggal ke nomor, tanggal berbeda

Ketika objek Date diubah menjadi angka, ia menjadi stempel waktu yang sama dengan date.getTime() :

 biarkan tanggal = Tanggal baru();
peringatan(+tanggal); // jumlah milidetik, sama seperti date.getTime()

Efek samping yang penting: tanggal bisa dikurangi, hasilnya selisihnya dalam ms.

Itu dapat digunakan untuk pengukuran waktu:

 biarkan mulai = Tanggal baru(); // mulai mengukur waktu

// melakukan pekerjaan itu
untuk (misalkan i = 0; i < 100000; i++) {
  biarkan melakukan Sesuatu = i * i * i;
}

biarkan akhir = Tanggal baru(); // waktu pengukuran akhir

alert( `Perulangan memerlukan waktu ${end - start} ms` );

Tanggal.sekarang()

Jika kita hanya ingin mengukur waktu, kita tidak membutuhkan objek Date .

Ada metode khusus Date.now() yang mengembalikan stempel waktu saat ini.

Secara semantik setara dengan new Date().getTime() , tetapi tidak membuat objek Date perantara. Jadi lebih cepat dan tidak memberi tekanan pada pengumpulan sampah.

Ini sebagian besar digunakan untuk kenyamanan atau ketika kinerja penting, seperti dalam game di JavaScript atau aplikasi khusus lainnya.

Jadi ini mungkin lebih baik:

 biarkan mulai = Tanggal.sekarang(); // milidetik dihitung mulai 1 Jan 1970

// melakukan pekerjaan itu
untuk (misalkan i = 0; i < 100000; i++) {
  biarkan melakukan Sesuatu = i * i * i;
}

biarkan akhir = Tanggal.sekarang(); // Selesai

alert( `Perulangan memerlukan waktu ${end - start} ms` ); // kurangi angka, bukan tanggal

Pembandingan

Jika kita menginginkan tolok ukur yang andal untuk fungsi yang membutuhkan CPU, kita harus berhati-hati.

Misalnya, mari kita ukur dua fungsi yang menghitung selisih antara dua tanggal: mana yang lebih cepat?

Pengukuran kinerja seperti ini sering disebut dengan “benchmark”.

 // kita punya tanggal1 dan tanggal2, fungsi mana yang lebih cepat mengembalikan selisihnya dalam ms?
fungsi diffSubtract(tanggal1, tanggal2) {
  tanggal kembali2 - tanggal1;
}

// atau
fungsi diffGetTime(tanggal1, tanggal2) {
  kembalikan tanggal2.getTime() - tanggal1.getTime();
}

Keduanya melakukan hal yang persis sama, tetapi salah satunya menggunakan date.getTime() eksplisit untuk mendapatkan tanggal dalam ms, dan yang lainnya mengandalkan transformasi tanggal-ke-angka. Hasil mereka selalu sama.

Jadi, mana yang lebih cepat?

Ide pertama mungkin adalah menjalankannya berkali-kali berturut-turut dan mengukur perbedaan waktunya. Untuk kasus kami, fungsinya sangat sederhana, jadi kami harus melakukannya setidaknya 100.000 kali.

Mari kita ukur:

 fungsi diffSubtract(tanggal1, tanggal2) {
  tanggal kembali2 - tanggal1;
}

fungsi diffGetTime(tanggal1, tanggal2) {
  kembalikan tanggal2.getTime() - tanggal1.getTime();
}

bangku fungsi(f) {
  biarkan tanggal1 = Tanggal baru(0);
  biarkan tanggal2 = Tanggal baru();

  biarkan mulai = Tanggal.sekarang();
  for (misalkan i = 0; i < 100000; i++) f(tanggal1, tanggal2);
  tanggal kembali.sekarang() - mulai;
}

alert('Waktu diffSubtract: '+bench(diffSubtract) + 'ms' );
alert('Waktu diffGetTime: '+bench(diffGetTime) + 'ms' );

Wow! Menggunakan getTime() jauh lebih cepat! Itu karena tidak ada konversi tipe, sehingga lebih mudah bagi mesin untuk mengoptimalkannya.

Oke, kita punya sesuatu. Namun itu belum menjadi tolak ukur yang baik.

Bayangkan pada saat menjalankan bench(diffSubtract) CPU sedang melakukan sesuatu secara paralel, dan menghabiskan sumber daya. Dan pada saat menjalankan bench(diffGetTime) pekerjaan itu telah selesai.

Skenario yang cukup nyata untuk OS multi-proses modern.

Akibatnya, benchmark pertama akan memiliki sumber daya CPU yang lebih sedikit dibandingkan benchmark kedua. Hal ini dapat menyebabkan hasil yang salah.

Untuk pembandingan yang lebih andal, seluruh paket tolok ukur harus dijalankan ulang beberapa kali.

Misalnya seperti ini:

 fungsi diffSubtract(tanggal1, tanggal2) {
  tanggal kembali2 - tanggal1;
}

fungsi diffGetTime(tanggal1, tanggal2) {
  kembalikan tanggal2.getTime() - tanggal1.getTime();
}

bangku fungsi(f) {
  biarkan tanggal1 = Tanggal baru(0);
  biarkan tanggal2 = Tanggal baru();

  biarkan mulai = Tanggal.sekarang();
  for (misalkan i = 0; i < 100000; i++) f(tanggal1, tanggal2);
  tanggal kembali.sekarang() - mulai;
}

biarkan waktu1 = 0;
misalkan waktu2 = 0;

// jalankan bench(diffSubtract) dan bench(diffGetTime) masing-masing 10 kali secara bergantian
untuk (misalkan i = 0; i < 10; i++) {
  time1 += bangku(diffSubtract);
  time2 += bangku(diffGetTime);
}

alert('Total waktu untuk diffSubtract: '+time1);
alert('Total waktu untuk diffGetTime: ' + time2 );

Mesin JavaScript modern mulai menerapkan pengoptimalan tingkat lanjut hanya pada “kode panas” yang dijalankan berkali-kali (tidak perlu mengoptimalkan hal-hal yang jarang dijalankan). Jadi, pada contoh di atas, eksekusi pertama tidak dioptimalkan dengan baik. Kami mungkin ingin menambahkan proses pemanasan:

 // ditambahkan untuk "pemanasan" sebelum loop utama
bangku(diffSubtract);
bangku(diffGetTime);

// sekarang menjadi patokan
untuk (misalkan i = 0; i < 10; i++) {
  time1 += bangku(diffSubtract);
  time2 += bangku(diffGetTime);
}

Hati-hati dalam melakukan microbenchmarking

Mesin JavaScript modern melakukan banyak optimasi. Mereka mungkin mengubah hasil “pengujian buatan” dibandingkan dengan “penggunaan normal”, terutama ketika kita melakukan tolok ukur pada sesuatu yang sangat kecil, seperti cara kerja operator, atau fungsi bawaan. Jadi jika Anda serius ingin memahami kinerjanya, silakan pelajari cara kerja mesin JavaScript. Dan Anda mungkin tidak memerlukan microbenchmark sama sekali.

Paket artikel hebat tentang V8 dapat ditemukan di https://mrale.ph.

Tanggal.parse dari sebuah string

Metode Date.parse(str) dapat membaca tanggal dari sebuah string.

Format stringnya harus: YYYY-MM-DDTHH:mm:ss.sssZ , dengan:

YYYY-MM-DD – adalah tanggal: tahun-bulan-tanggal.
Karakter "T" digunakan sebagai pembatas.
HH:mm:ss.sss – adalah waktu: jam, menit, detik, dan milidetik.
Bagian 'Z' opsional menunjukkan zona waktu dalam format +-hh:mm . Satu huruf Z berarti UTC+0.

Varian yang lebih pendek juga dimungkinkan, seperti YYYY-MM-DD atau YYYY-MM atau bahkan YYYY .

Panggilan ke Date.parse(str) mem-parsing string dalam format yang diberikan dan mengembalikan stempel waktu (jumlah milidetik mulai 1 Jan 1970 UTC+0). Jika formatnya tidak valid, kembalikan NaN .

Misalnya:

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

peringatan(ms); // 1327611110417 (cap waktu)

Kita dapat langsung membuat objek new Date dari stempel waktu:

 biarkan tanggal = Tanggal baru( Tanggal.parse('26-01-2012T13:51:50.417-07:00') );

peringatan(tanggal);

Ringkasan

Tanggal dan waktu dalam JavaScript direpresentasikan dengan objek Date. Kita tidak bisa membuat “tanggal saja” atau “waktu saja”: Objek Date selalu membawa keduanya.
Bulan dihitung dari nol (ya, Januari adalah bulan nol).
Hari dalam seminggu di getDay() juga dihitung dari nol (yaitu hari Minggu).
Date terkoreksi secara otomatis ketika komponen di luar jangkauan disetel. Cocok untuk menambah/mengurangi hari/bulan/jam.
Tanggal dapat dikurangi, memberikan selisihnya dalam milidetik. Itu karena Date menjadi stempel waktu ketika diubah menjadi angka.
Gunakan Date.now() untuk mendapatkan stempel waktu saat ini dengan cepat.

Perhatikan bahwa tidak seperti banyak sistem lain, stempel waktu dalam JavaScript dalam milidetik, bukan dalam hitungan detik.

Terkadang kita membutuhkan pengukuran waktu yang lebih tepat. JavaScript sendiri tidak memiliki cara untuk mengukur waktu dalam mikrodetik (1 sepersejuta detik), namun sebagian besar lingkungan menyediakannya. Misalnya, browser memiliki performance.now() yang memberikan jumlah milidetik dari awal pemuatan halaman dengan presisi mikrodetik (3 digit setelah titik):

 alert(`Pemuatan dimulai ${performa.sekarang()}mdtk yang lalu`);
// Sesuatu seperti: "Pemuatan dimulai 34731.26000000001 ms yang lalu"
// .26 adalah mikrodetik (260 mikrodetik)
// lebih dari 3 digit setelah koma merupakan kesalahan presisi, hanya 3 digit pertama yang benar

Node.js memiliki modul microtime dan cara lainnya. Secara teknis, hampir semua perangkat dan lingkungan memungkinkan untuk mendapatkan lebih banyak presisi, hanya saja tidak ada di Date .

Tugas

Buat kencan

pentingnya: 5

Buat objek Date untuk tanggal: 20 Februari 2012, 3:12 pagi. Zona waktu bersifat lokal.

Tunjukkan dengan menggunakan alert .

Konstruktor new Date menggunakan zona waktu lokal. Jadi satu-satunya hal yang penting untuk diingat adalah bahwa bulan dimulai dari nol.

Jadi Februari punya nomor 1.

Berikut ini contoh dengan angka sebagai komponen tanggal:

 //Tanggal baru(tahun, bulan, tanggal, jam, menit, detik, milidetik)
misalkan d1 = Tanggal baru(2012, 1, 20, 3, 12);
peringatan( d1 );

Kita juga bisa membuat tanggal dari sebuah string, seperti ini:

 //Tanggal baru(string data)
biarkan d2 = Tanggal baru("20-02-2012T03:12");
peringatan( d2 );

Tampilkan hari kerja

pentingnya: 5

Tulis fungsi getWeekDay(date) untuk menampilkan hari kerja dalam format singkat: 'MO', 'TU', 'WE', 'TH', 'FR', 'SA', 'SU'.

Misalnya:

 biarkan tanggal = Tanggal baru(2012, 0, 3);  // 3 Januari 2012
peringatan(getWeekDay(tanggal) );        // harus menampilkan "TU"

Buka kotak pasir dengan tes.

Metode date.getDay() mengembalikan nomor hari kerja, dimulai dari hari Minggu.

Mari kita buat array hari kerja, sehingga kita bisa mendapatkan nama hari yang tepat berdasarkan nomornya:

 fungsi getWeekDay(tanggal) {
  biarkan hari = ['SU', 'MO', 'TU', 'WE', 'TH', 'FR', 'SA'];

  hari pengembalian[tanggal.getDay()];
}

biarkan tanggal = Tanggal baru(2014, 0, 3); // 3 Januari 2014
peringatan(getWeekDay(tanggal) ); // Perancis

Buka solusi dengan pengujian di kotak pasir.

hari kerja Eropa

pentingnya: 5

Negara-negara Eropa memiliki hari dalam seminggu yang dimulai dari Senin (nomor 1), lalu Selasa (nomor 2) dan hingga Minggu (nomor 7). Tulis fungsi getLocalDay(date) yang mengembalikan hari “Eropa” untuk date .

 biarkan tanggal = Tanggal baru(2012, 0, 3);  // 3 Januari 2012
peringatan( getLocalDay(tanggal) );       // Selasa, seharusnya menampilkan 2

Buka kotak pasir dengan tes.

 fungsi getLocalDay(tanggal) {

  biarkan hari = tanggal.getDay();

  if (day == 0) { // hari kerja 0 (minggu) adalah 7 di eropa
    hari = 7;
  }

  hari kepulangan;
}

Buka solusi dengan pengujian di kotak pasir.

Hari apa dalam sebulan beberapa hari yang lalu?

pentingnya: 4

Buat fungsi getDateAgo(date, days) untuk mengembalikan hari dalam sebulan, days yang lalu dari date .

Misalnya, jika hari ini tanggal 20, maka getDateAgo(new Date(), 1) harusnya tanggal 19 dan getDateAgo(new Date(), 2) harusnya tanggal 18.

Harus bekerja dengan andal selama days=365 atau lebih:

 biarkan tanggal = Tanggal baru(2015, 0, 2);

peringatan( getDateAgo(tanggal, 1) ); // 1, (1 Januari 2015)
peringatan( getDateAgo(tanggal, 2) ); // 31, (31 Des 2014)
peringatan( getDateAgo(tanggal, 365) ); // 2, (2 Januari 2014)

PS Fungsinya tidak boleh mengubah date yang ditentukan.

Buka kotak pasir dengan tes.

Idenya sederhana: untuk mengurangi jumlah hari tertentu dari date :

 fungsi getDateAgo(tanggal, hari) {
  tanggal.setDate(tanggal.getDate() - hari);
  tanggal pengembalian.getDate();
}

…Tetapi fungsinya tidak boleh mengubah date . Itu merupakan hal yang penting, karena kode luar yang memberi kita tanggal tidak mengharapkannya untuk berubah.

Untuk mengimplementasikannya mari kita kloning tanggalnya, seperti ini:

 fungsi getDateAgo(tanggal, hari) {
  biarkan dateCopy = Tanggal baru(tanggal);

  dateCopy.setDate(tanggal.getDate() - hari);
  return dateCopy.getDate();
}

biarkan tanggal = Tanggal baru(2015, 0, 2);

peringatan( getDateAgo(tanggal, 1) ); // 1, (1 Januari 2015)
peringatan( getDateAgo(tanggal, 2) ); // 31, (31 Des 2014)
peringatan( getDateAgo(tanggal, 365) ); // 2, (2 Januari 2014)

Buka solusi dengan pengujian di kotak pasir.

Hari terakhir bulan ini?

pentingnya: 5

Tulis fungsi getLastDayOfMonth(year, month) yang mengembalikan hari terakhir dalam sebulan. Terkadang tanggal 30, 31 atau bahkan 28/29 untuk bulan Februari.

Parameter:

year – tahun empat digit, misalnya 2012.
month – bulan, dari 0 hingga 11.

Misalnya, getLastDayOfMonth(2012, 1) = 29 (tahun kabisat, Feb).

Buka kotak pasir dengan tes.

Mari kita buat tanggal menggunakan bulan berikutnya, tetapi tetapkan nol sebagai hari:

 fungsi getLastDayOfMonth(tahun, bulan) {
  misalkan tanggal = Tanggal baru(tahun, bulan + 1, 0);
  tanggal pengembalian.getDate();
}

peringatan( getLastDayOfMonth(2012, 0) ); // 31
peringatan( getLastDayOfMonth(2012, 1) ); // 29
peringatan( getLastDayOfMonth(2013, 1) ); // 28

Biasanya, tanggal dimulai dari 1, tetapi secara teknis kita dapat memasukkan angka berapa pun, tanggal akan menyesuaikan sendiri secara otomatis. Jadi bila kita melewati 0, maka artinya “satu hari sebelum tanggal 1 bulan itu”, dengan kata lain: “hari terakhir bulan sebelumnya”.

Buka solusi dengan pengujian di kotak pasir.

Berapa detik telah berlalu hari ini?

pentingnya: 5

Tulis fungsi getSecondsToday() yang mengembalikan jumlah detik dari awal hari ini.

Misalnya, jika saat ini 10:00 am , dan tidak ada shift musim panas, maka:

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

Fungsi ini harus berfungsi kapan saja. Artinya, kata tersebut tidak boleh memiliki nilai “hari ini” yang dikodekan secara keras.

Untuk mendapatkan jumlah detik, kita dapat membuat tanggal menggunakan hari dan waktu saat ini 00:00:00, lalu menguranginya dengan “sekarang”.

Selisihnya adalah jumlah milidetik dari awal hari, yang harus kita bagi dengan 1000 untuk mendapatkan detik:

 fungsi getSecondsToday() {
  biarkan sekarang = Tanggal baru();

  // membuat objek menggunakan hari/bulan/tahun saat ini
  biarkan hari ini = Tanggal baru(sekarang.getFullYear(), sekarang.getMonth(), sekarang.getDate());

  let diff = sekarang - hari ini; // perbedaan ms
  return Math.round(diff / 1000); // membuat detik
}

peringatan( getSecondsToday() );

Solusi alternatifnya adalah mendapatkan jam/menit/detik dan mengubahnya menjadi detik:

 fungsi getSecondsToday() {
  misalkan d = Tanggal baru();
  kembalikan d.getHours() * 3600 + d.getMinutes() * 60 + d.getSeconds();
}

peringatan( getSecondsToday() );

Berapa detik sampai besok?

pentingnya: 5

Buat fungsi getSecondsToTomorrow() yang mengembalikan jumlah detik hingga besok.

Misalnya, jika sekarang adalah 23:00 , maka:

 getSecondsToTomorrow() == 3600

PS Fungsinya harus berfungsi kapan saja, "hari ini" tidak di-hardcode.

Untuk mendapatkan jumlah milidetik hingga besok, kita dapat mengurangi tanggal sekarang dari “besok 00:00:00”.

Pertama, kita buat "besok" itu, lalu lakukan:

 fungsi getSecondsToTomorrow() {
  biarkan sekarang = Tanggal baru();

  // tanggal besok
  biarkan besok = Tanggal baru(sekarang.getFullYear(), sekarang.getMonth(), sekarang.getDate()+1);

  let diff = besok - sekarang; // perbedaan ms
  return Math.round(diff / 1000); // ubah ke detik
}

Solusi alternatif:

 fungsi getSecondsToTomorrow() {
  biarkan sekarang = Tanggal baru();
  biarkan jam = sekarang.getHours();
  biarkan menit = sekarang.getMinutes();
  biarkan detik = sekarang.getSeconds();
  misalkan totalSecondsToday = (jam * 60 + menit) * 60 + detik;
  misalkan totalSecondsInADay = 86400;

  kembalikan totalSecondsInADay - totalSecondsToday;
}

Harap dicatat bahwa banyak negara mempunyai Waktu Musim Panas (DST), jadi mungkin ada hari-hari dengan 23 atau 25 jam. Kita mungkin ingin memperlakukan hari-hari seperti itu secara terpisah.

Format tanggal relatif

pentingnya: 4

Tulis fungsi formatDate(date) yang harus memformat date sebagai berikut:

Jika sejak date berlalu kurang dari 1 detik, maka "right now" .
Sebaliknya, jika sejak date berlalu kurang dari 1 menit, maka "n sec. ago" .
Sebaliknya, jika kurang dari satu jam, maka "m min. ago" .
Jika tidak, tanggal lengkap dalam format "DD.MM.YY HH:mm" . Yaitu: "day.month.year hours:minutes" , semuanya dalam format 2 digit, misalnya 31.12.16 10:00 .

Misalnya:

 peringatan( formatTanggal(Tanggal baru(Tanggal baru - 1)) ); // "sekarang"

alert( formatDate(Tanggal baru(Tanggal baru - 30*1000)) ); // "30 detik yang lalu"

alert( formatDate(Tanggal baru(Tanggal baru - 5*60*1000)) ); // "5 menit yang lalu"

// tanggal kemarin seperti 31.12.16 20:00
peringatan( formatTanggal(Tanggal baru(Tanggal baru - 86400 * 1000)) );

Buka kotak pasir dengan tes.

Untuk mendapatkan waktu dari date sampai sekarang – mari kita kurangi tanggalnya.

 fungsi formatTanggal(tanggal) {
  biarkan diff = Tanggal baru() - tanggal; // perbedaannya dalam milidetik

  if (diff < 1000) {// kurang dari 1 detik
    kembalikan 'sekarang';
  }

  biarkan detik = Math.floor(diff / 1000); // ubah diff menjadi detik

  jika (detik < 60) {
    kembali detik + 'detik. yang lalu';
  }

  let min = Math.floor(diff / 60000); // ubah diff menjadi menit
  jika (min < 60) {
    kembali min + ' min. yang lalu';
  }

  // memformat tanggal
  // menambahkan angka nol di depan ke satu digit hari/bulan/jam/menit
  misalkan d = tanggal;
  d = [
    '0' + d.getDate(),
    '0' + (d.getBulan() + 1),
    ''+d.getFullYear(),
    '0' + d.getJam(),
    '0' + d.getMinutes()
  ].map(komponen => komponen.slice(-2)); // ambil 2 digit terakhir dari setiap komponen

  // menggabungkan komponen-komponen menjadi tanggal
  return d.slice(0, 3).join('.') + ' ' + d.slice(3).join(':');
}

peringatan( formatTanggal(Tanggal baru(Tanggal baru - 1)) ); // "sekarang"

alert( formatDate(Tanggal baru(Tanggal baru - 30*1000)) ); // "30 detik yang lalu"

alert( formatDate(Tanggal baru(Tanggal baru - 5*60*1000)) ); // "5 menit yang lalu"

// tanggal kemarin seperti 31.12.2016 20:00
peringatan( formatTanggal(Tanggal baru(Tanggal baru - 86400 * 1000)) );

Solusi alternatif:

 fungsi formatTanggal(tanggal) {
  biarkan dayOfMonth = tanggal.getDate();
  biarkan bulan = tanggal.getMonth() + 1;
  biarkan tahun = tanggal.getFullYear();
  biarkan jam = tanggal.getHours();
  biarkan menit = tanggal.getMinutes();
  biarkan diffMs = Tanggal baru() - tanggal;
  biarkan diffSec = Math.round(diffMs / 1000);
  biarkan diffMin = diffSec / 60;
  biarkan diffHour = diffMin / 60;

  // memformat
  tahun = tahun.toString().slice(-2);
  bulan = bulan < 10 ? '0' + bulan : bulan;
  hariBulan = hariBulan < 10 ? '0' + hariBulan : hariBulan;
  jam = jam < 10 ? '0' + jam : jam;
  menit = menit < 10 ? '0' + menit : menit;

  jika (diffSec < 1) {
    kembalikan 'sekarang';
  } else if (diffMin < 1) {
    kembalikan `${diffSec} detik. lalu`
  } else if (diffHour < 1) {
    kembalikan `${diffMin} mnt. lalu`
  } kalau tidak {
    kembalikan `${dayOfMonth}.${bulan}.${tahun} ${jam}:${menit}`
  }
}

Buka solusi dengan pengujian di kotak pasir.