1 September 2021

Tanggal dan waktu

Ayo kita bertemu dengan objek bawaan baru: Date. yang akan menyimpan tanggal, waktu dan menyediakan metode untuk manajemen tanggal/waktu.

Contoh, kita bisa menggunakan itu untuk menyimpan pembuatan/modifikasi waktu, untuk menghitung waktu atau hanya untuk melihat tanggal sekarang.

Pembuatan

Untuk membuat objek Date baru panggil new Date() dengan salah satu dari argumen dibawah:

new Date()

Tanpa argumen ??? membuat sebuah objek Date untuk tanggal dan waktu sekarang:

let now = new Date();
alert( now ); // tampilkan tanggal/waktu sekarang
new Date(milliseconds)

Membuat sebuah objek Date dengan waktu yang sama dengan mili-detik (1/1000 dari satu detik) lewat dari Januari 1 1970 UTC+0.

// 0 berarti 01.01.1970 UTC+0
let Jan01_1970 = new Date(0);
alert( Jan01_1970 );

// sekarang tambahkan 24 jam, ambil 02.01.1970 UTC+0
let Jan02_1970 = new Date(24 * 3600 * 1000);
alert( Jan02_1970 );

Sebuah angka integer merepresentasikan angka dari milidetik yang telah lewat sejak awal dari 1970 dipanggil dengan timestamp.

Ini adalah angka numerik ringan yang merepresentasikan sebuah tanggal. Kita akan selalu bisa membuat tanggal dari timestamp menggunakan new Date(timestamp) dan mengubah objek Date yang ada ke sebuah timestamp dengan menggunakan metode date.getTime() (lihat dibawah).

Tanggal sebelum 01.01.1970 mempunyai timestamp yang negatif, contoh.:

// 31 Dec 1969
let Dec31_1969 = new Date(-24 * 3600 * 1000);
alert( Dec31_1969 );
new Date(datestring)

Jika terdapat sebuah argumen tunggal, dan itu adalah sebuah string, lalu itu akan diurai secara otomatis. Algoritmanya sama dengan yang digunakan Date.parse, kita akan pelajari itu nanti.

let date = new Date("2017-01-26");
alert(date);
// Waktunya belum di set, jadi itu diasumsikan tengah malam GMT dan
// disesuaikan menurut zona waktu dimana kodenya berjalan
// Jadi hasilnya mungkin bisa
// Kamis Jan 26 2017 11:00:00 GMT+1100 (Waktu timur siang hari Australia )
// atau
// Rabu Jan 25 2017 16:00:00 GMT-0800 (Waktu standar pasifik)
new Date(year, month, date, hours, minutes, seconds, ms)

Membuat waktu dengan komponen yang diberikan dari zona waktu lokal. Hanya dua argument pertama yang wajib.

  • Tahunnya harus mempunyai 4 angka: 2013 boleh, 98 tidak boleh.
  • Perhitungan Bulannya dimulai dari 0 (Jan), sampai 11 (Des).
  • Parameter date sebenarnya adalah hari dari bulan, jika tidak ada maka akan diasumsikan 1.
  • Jika jam/menit/detik/milidetik tidak ada, mereka akan diasumsikan sama dengan 0.

Contoh:

new Date(2011, 0, 1, 0, 0, 0, 0); // 1 Jan 2011, 00:00:00
new Date(2011, 0, 1); // sama, jam dan yang lainnya secara default adalah 0

Presisi paling minimal adalah 1ms (1/1000 detik):

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

Mengakses komponen tanggal

Terdapat beberapa metode untuk mengakses tahun, bulan dan lainnya dari objek Date:

getFullYear()
Mendapatkan tahun (4 angka)
getMonth()
Mendapatkan bulan, dari 0 sampai 11.
getDate()
mendapatkan hari dari bulan, dari 1 sampai 31, nama dari metodenya sedikit terlihat aneh.
getHours(), getMinutes(), getSeconds(), getMilliseconds()
Mendapatkan komponen-komponen yang bersangkutan.
Bukan getYear(), Tapi getFullYear()

Banyak mesin Javascript mengimplementasikan metode yang tidak-standar getYear(). Metode ini sudah usang. Itu terkadang mengembalikan tahun dengan 2-angka. Tolong jangan gunakan itu. Gunakan getFullYear() untuk tahun.

Sebagai tambahan, kita bisa mendapatkan hari dari minggu:

getDay()
Dapatkan hari dari minggu, dimulai dari 0 (Minggu) to 6 (Sabtu). Hari pertama akan selalu Minggu, di beberapa negara bukanlah minggu, dan tidak bisa diubah.

Semua metode diatas mengembalikan komponen yang bersangkutan dengan zona waktu lokal.

Juga terdapat pasangan-UTC, yang mengembalikan hari bulan, tahun dan lainnya untuk zona waktu UTC+0: getUTCFullYear(), getUTCMonth(), getUTCDay(). Hanya dengan memasukan "UTC" tepat setelah "get".

Jika zona waktu lokal kamu diubah menjadi zona yang berhubungan dengan UTC, maka kode dibawah akan menunjukan waktu yang berbeda.

// tanggal sekarang
let date = new Date();

// jam didalam zona waktu kamu sekarang
alert( date.getHours() );

// jam di zona waktu UTC+0 (waktu london tanpa waktu musim panas)
alert( date.getUTCHours() );

Disamping metode yang diberikan, disana terdapat dua yang spesial yang tidak memiliki variasi waktu UTC:

getTime()

Mengembalikan timestamp untuk tanggal ??? sebuah angka dari milidetik yang telah terlewat sejak 1 Januari 1970 UTC+0

getTimezoneOffset()

Mengembalikan perbedaan diantara UTC dan zona waktu lokal, dalam menit:

// jika kamu berada didalam zona waktu UTC-1, mengeluarkan 60
// jika kamu berada di zona waktu UTC+3, mengeluarkan -180
alert( new Date().getTimezoneOffset() );

Menyetel komponen tanggal

Metode berikut memperbolehkan kita untuk menyetel komponen tanggal/waktu:

Semuanya kecuali salah satunya yaitu setTime() mempunyai varian-UTC, contoh: setUTCHours().

Seperti yang bisa kita lihat, beberapa metode bisa menyetel beberapa komponen sekaligus, untuk contoh setHours. Komponen yang tidak disebutkan tidak akan diubah.

Contoh:

let today = new Date();

today.setHours(0);
alert(today); // masih hari ini, tapi jamnya diubah menjadi 0

today.setHours(0, 0, 0, 0);
alert(today); // masih hari ini, tapi tepat 00:00:00

Koreksi otomatis

Koreksi otomatis adalah fitur yang sangat berguna dari objek Date. Kita bisa menyetel nilai yang diluar jangkauan, dan itu akan menyesuaikan dirinya sendiri.

Contoh:

let date = new Date(2013, 0, 32); // 32 Jan 2013 ?!?
alert(date); // ...adalah 1st Feb 2013!

komponen tanggal yang diluar jangkauan akan diganti secara otomatis.

Kita bisa berkata untuk menambah tanggal ???28 feb 2016??? dengan 2 hari. Itu mungkin akan ???2 maret??? atau ???1 maret??? didalam kasus tahun kabisat. Kita tidak perlu memikirkan hal itu. Tinggal tambah 2 hari. Objek Date akan melakukan sisanya:

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

alert( date ); // 1 Mar 2016

Fitur itu sering digunakan untuk mendapatkan tanggal setelah diberikan waktu yang ditentukan, coba dapatkan tanggal ???70 detik setelah saat ini???:

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

alert( date ); // menampilkan tanggal yang benar

Kita juga bisa menyetel nol atau bahkan nilai negatif. Contoh:

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

date.setDate(1); // setel hari pertama dari bulan
alert( date );

date.setDate(0); // kurangi 1 hari, jadi diasumsikan hari terakhir di bulan sebelumnya

alert( date ); // 31 Desember 2015

Tanggal menjadi angka, perbedaan tanggal

Ketika sebuah objek Date diubah menjadi angka, itu menjadi timestamp sama seperti date.getTime():

let date = new Date();
alert(+date); // angka dari milidetik, sama seperti date.getTime()

Efek yang perlu diperhatikan: tanggal bisa dikurangi, hasilnya adalah perbedaan dalam milidetik.

Hal itu bisa gunakan untuk mengukur waktu:

let start = new Date(); // mulai pengukuran waktu

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

let end = new Date(); // akhiri pengukuran waktu

alert( `The loop took ${end - start} ms` );

Date.now()

Jika kita ingin mengukur waktu, kita tidak butuh objek Date.

Terdapat metode spesial Date.now() yang mengembalikan timestamp saat ini.

Itu secara semaktik sama dengan new Date().getTime(), tapi itu tidak menciptakan sebuah perantara objek Date. Jadi itu lebih cepat dan tidak menambah beban pembuangan sampah.

Kebanyakan itu digunakan untuk kenyamanan atau ketika performansi menjadi hal yang diperhatikan, seperti permainan didalam Javascript atau aplikasi yang terspesialisasi lainnya.

Jadi ini mungkin lebih baik:

let start = Date.now(); // milidetik dihitung dari 1 Januari 1970

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

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

alert( `The loop took ${end - start} ms` ); // kurangi angka, bukan tanggal

Menguji kemampuan / Benchmarking

Jika kita ingin kemampuan yang dapat diandalkan dari fungsi yang haus akan sumberdaya CPU, kita harus hati-hati.

Contoh, coba kita bandingkan dua fungsi yang mengkalkulasikan perbedaan diantara dua tanggal: yang mana yang lebih cepat?

Pengukurang performa seperti itu sering disebut dengan ???benchmarks???.

// kita punya date1 dan date2, fungsi yang mana yang lebih cepat mengembalikan perbedaannya dalam milidetik?
function diffSubtract(date1, date2) {
  return date2 - date1;
}

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

kedua fungsi itu melakukan hal yang sama persis, tapi satu dari mereka menggunakan date.getTime() secara eksplisit untuk mendapatkan tanggal dalam milidetik, dan lainnya menggunakan perubahan tanggal-ke-angka. Hasil mereka akan selalu sama.

Jadi, yang mana yang lebih cepat?

Cara sederhananya mungkin menjalankan mereka beberapa kali dan menghitung perbedaan waktunya. Untuk kasus ini, fungsi sangatlah sederhana, jadi kita hanya harus melakukannya setidaknya 100000 kali.

Ayo kita hitung:

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

Wow! Menggunakan getTime() lebih cepat! itu karena disana tidak terdapat perubahan tipe, itu akan membuat mesinnya lebih mudah dalam mengoptimasi.

Oke, kita punya sesuatu. Tapi itu bukanlah sebuah pengujian kemampuan yang bagus.

Bayangkan itu pada saat menjalankan bench(diffSubtract) CPU nya sedang melakukan sesuatu yang lain, dan itu mengambil sumberdaya nya. Dan pada saat menjalankan bench(diffGetTime) pekerjaanya telah selesai.

Sebuah skenario nyata untuk Sistem Operasi multi-proses yang modern.

Sebagai sebuah hasil, pengujian kemampuan pertama mempunyai sedikit sumberdaya CPU daripada yang kedua. Itu mungkin akan mengakibatkan hasil menjadi keliru.

Untuk pengujian yang lebih dapat diandalkan, seluruh pengujian harus dijalankan beberapa kali.

Contoh, seperti ini:

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;

// jalankan bench(upperSlice) dan bench(upperLoop) setiap 10 kali bergantian
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 );

Mesin Javascript yang modern mulai menggunakan optimasi yang tinggi hanya untuk ???hot code??? yang dieksekusi beberapa kali (tidak butuh untuk optimasi hal yang jarang dieksekusi). Jadi, dalam contoh diatas, eksekusi pertama tidak benar-benar di optimasi. Kita mungkin butuh menambah sebuah pemanasan:

// ditambahkan untuk "memanaskan" terlebih dahulu perulangan utama
bench(diffSubtract);
bench(diffGetTime);

// sekarang benchmark
for (let i = 0; i < 10; i++) {
  time1 += bench(diffSubtract);
  time2 += bench(diffGetTime);
}
Berhati-hati saat melakukan microbenchmarking/pengujian kemampuan micro

Mesin Javascript modern melakukan banyak optimasi. mereka mungkin merekayasa hasil dari ???test buatan??? dibandingkan dengan ???pemakaian normal???, terutama ketika kita mengukur kemampuan sesuatu yang sangat kecil, seperti bagaimana operator bekerja, atau fungsi bawaan. Jadi jika kamu sangat serius ingin mengerti tentang performansi, maka pelajarilah bagaiman mesin Javascript bekerja. dan maka kamu mungkin tidak butuh microbenchmarking sama sekali

Kumpulan artikel yang bagus tentang V8 bisa ditemukan di http://mrale.ph.

Date.parse dari sebuah string

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

Bentuk dari string haruslah: YYYY-MM-DDTHH:mm:ss.sssZ, dimana:

  • YYYY-MM-DD ??? adalah tanggal: tahun-bulan-hari.
  • Karakter dari "T" digunakan sebagai pembatas.
  • HH:mm:ss.sss ??? adalah waktu: jam, menit, detik dan milidetik.
  • Bagian opsional 'Z' menandakan zona waktu dalam format +-hh:mm. Huruf tunggal Z menandakan UTC+0.

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

Pemanggilan Date.parse(str) mengolah string dalam bentuk yang diberikan dan mengembalikan timestamp (angka dalam milidetik dari 1 Januari 1970 UTC+0). Jika formatnya tidak valid, akan mengembalikan NaN.

Contoh:

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

alert(ms); // 1327611110417  (timestamp)

Kita bisa secara instan membuat sebuah objek new Date dari timestamp:

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

alert(date);

Ringkasan

  • Tanggal dan waktu dalam Javascript direpresentasikan oleh objek Date. Kita tidak bisa membuat ???hanya tanggal??? atau ???hanya waktu???: objek Date selalu membawa keduanya.
  • Bulan dihitung dari nol (ya, Januari adalah bulan ke-nol)
  • Hari-hari di minggu di getDay() juga dihitung dari nol (yang mana adalah minggu).
  • Date mengkoreksi sendiri secara otomatis ketika komponen diluar jangkauan di-set. Bagus unduk menambahkan/mengurangi hari/bulan/jam.
  • Tanggal bisa dikurangi, memberikan perbedaannya dalam milidetik. Itu karena Date menjadi timestamp ketika diubah menjadi angka.
  • Gunakan Date.now() untuk mendapatkan timestamp dengan cepat.

Perhatikan tidak seperti sistem lainnya, timestamp didalam Javascript adalah dalam milidetik, bukan dalam detik.

Terkadang kita ingin pengukuran yang lebih teliti. Javascript sendiri tidak mendukung cara untuk mengukur waktu didalam microdetik (1 juta dalam satu detik), tapi kebanyakan lingkungan menyediakannya. Contoh, peramban punya performance.now() yang memberikan angka milidetik dari awal halaman dimuat dengan ketepatan microdetik (3 angka setelah titik):

alert(`Loading started ${performance.now()}ms ago`);
// Sesuatu seperti: "Loading started 34731.26000000001ms ago"
// .26 adalah microdetik (260 microdetik)
// lebih dari 3 angka setelah titik desimal adalah presisi error, tapi hanya 3 yang benar

Node.js punya modul microtime dan cara lainnya. Secara teknis, hampir kebanyakan perangkat dan environment memperbolehkan untuk mendapatkan presisi, itu hanya bukan didalam Date.

Tugas

Buat sebuah objek Date untuk tanggal: Feb 20, 2012, 3:12am. Zona waktu lokal.

Tampilkan menggunakan alert.

Konstruktor new Date menggunakan zona waktu lokal. Sehingga hal penting yang harus diingat adalah bulan dimulai dari angka 0.

Jadi Februari mempunyai angka 1.

Here???s an example with numbers as date components:

//new Date(year, month, date, hour, minute, second, millisecond)
let d1 = new Date(2012, 1, 20, 3, 12);
alert( d1 );

We could also create a date from a string, like this:

//new Date(datastring)
let d2 = new Date("February 20, 2012 03:12:00");
alert( d2 );

Tulis sebuah fungsi getWeekDay(tanggal) untuk menunjukkan hari dalam format: ???SEN???, ???SEL???, ???RAB???, ???KAM???, ???JUM???, ???SAB???, ???MIN???.

Sebagai contoh:

let tanggal = new Date(2012, 0, 3);  // 3 Jan 2012
alert( getWeekDay(tanggal) );        // harus mengeluarkan "SEL"

Buka sandbox dengan tes.

Metode date.getDay() mengembalikan angka dari hari dalam satu minggu, dimulai dari Minggu.

Buat array hari dalam seminggu, sehingga kita bisa mendapatkan nama yang sesuai dengan angkanya:

function getWeekDay(date) {
  let days = ['MIN', 'SEN', 'SEL', 'RAB', 'KAM', 'JUM', 'SAB'];

  return days[date.getDay()];
}

let date = new Date(2014, 0, 3); // 3 Jan 2014
alert( getWeekDay(date) ); // JUM

Buka solusi dengan tes di sandbox.

Negara-negara di Eropa mempunyai hari yang dimulai dari Senin (angka 1), kemudian Selasa (angka 2) sampai dengan Minggu (angka 7). Buatlah sebuah fungsi getLocalDay(date) yang mengembalikan hari sesuai dengan standar tanggal di Eropa.

let date = new Date(2012, 0, 3);  // 3 Jan 2012
alert( getLocalDay(date) );       // Selasa, seharusnya menunjukkan angka 2

Buka sandbox dengan tes.

function getLocalDay(date) {

  let days = date.getDay();

  if (days == 0) { // hari ke-0 (Minggu) adalah hari ke-7 di Eropa
    days = 7;
  }

  return days;
}

Buka solusi dengan tes di sandbox.

Buatlah sebuah fungsi getDateAgo(tanggal, hari) yang mengembalikan beberapa hari yang telah berlalu dari sebuah tanggal.

Sebagai contoh, apabila hari ini tanggal 20, maka getDateAgo(new Date(), 1) harus mengembalikan tanggal 19 dan getDateAgo(new Date(), 2) harus mengembalikan tanggal 18.

Harus bekerja dengan baik dan dapat diandalkan untuk hari=365 atau lebih:

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

alert( getDateAgo(tanggal, 1) ); // 1, (1 Jan 2015)
alert( getDateAgo(tanggal, 2) ); // 31, (31 Des 2014)
alert( getDateAgo(tanggal, 365) ); // 2, (2 Jan 2014)

P.S. Fungsi tidak boleh mengubah tanggal yang diberikan.

Buka sandbox dengan tes.

Idenya mudah: Kurangi tanggal dengan jumlah hari yang diberikan.

function getDateAgo(tanggal, hari) {
  tanggal.setDate(tanggal.getDate() - hari);
  return tanggal.getDate();
}

???Namun fungsi tersebut tidak boleh mengubah tanggal yang diberikan. Ini adalah yang terpenting, karena kode di luar yang memberikan kita tanggal tidak mengira tanggal tersebut akan berubah.

Untuk mengimplementasikannya kita akan menduplikasi tanggal tersebut, seperti ini:

function getDateAgo(tanggal, hari) {
  let tanggalCopy = new Date(tanggal);

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

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

alert( getDateAgo(tanggal, 1) ); // 1, (1 Jan 2015)
alert( getDateAgo(tanggal, 2) ); // 31, (31 Des 2014)
alert( getDateAgo(tanggal, 365) ); // 2, (2 Jan 2014)

Buka solusi dengan tes di sandbox.

Tulis sebuah fungsi getLastDayOfMonth(tahun, bulan) yang mengembalikan tanggal terakhir dari sebuah bulan. Terkadang 30, 31, atau bahkan 28/29 untuk Februari.

Parameter:

  • tahun ??? tahun dalam empat-digit, sebagai contoh 2012.
  • bulan ??? bulan, dari 0 sampai 11.

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

Buka sandbox dengan tes.

Buat sebuah tanggal menggunakan bulan berikutnya, namun berikan 0 sebagai tanggalnya:

function getLastDayOfMonth(tahun, bulan) {
  let tanggal = new Date(tahun, bulan + 1, 0);
  return tanggal.getDate();
}

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

Normalnya, tanggal dimulai dari 1, namun secara teknis kita bisa berikan angka apapun, dan tanggal akan otomatis menyesuaikan. Sehingga ketika kita berikan 0, itu berarti ???satu hari sebelum tanggal pertama untuk sebuah bulan???, dengan kata lain: ???hari terakhir pada bulan sebelumnya???.

Buka solusi dengan tes di sandbox.

Tulis sebuah fungsi getSecondsToday() yang mengembalikan angka dari detik yang telah berlalu dari sejak permulaan hari ini.

Sebagai contoh, sekarang pukul 10:00 am, dan tidak ada daylight savings shift, maka:

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

Fungsi haruslah berjalan untuk hari apapun. sehingga, tidak boleh ada nilai ???hari ini??? yang ditulis secara hard-code.

Untuk mendapatkan jumlah detik, kita harus membuat sebuah tanggal menggunakan hari yang sedang berlangsung dan waktu 00:00:00, dan mengurangi waktu ???saat ini??? dengannya.

Perbedaan yang didapat adalah angka dalam milidetik sejak permulaan hari, yang harus dibagi dengan 1000 agar menjadi detik:

function getSecondsToday() {
  let sekarang = new Date();

  // Buat sebuah objek menggunakan hari/bulan/tahun saat ini
  let hariIni = new Date(now.getFullYear(), now.getMonth(), now.getDate());

  let beda = sekarang - hariIni; // beda dalam milidetik
  return Math.round(beda / 1000); // ubah menjadi detik
}

alert( getSecondsToday() );

Solusi alternatif adalah cari jam/menit/detik dan ubah menjadi detik:

function getSecondsToday() {
  let d = new Date();
  return d.getHours() * 3600 + d.getMinutes() * 60 + d.getSeconds();
}

alert( getSecondsToday() );

Buat sebuah fungsi getSecondsToTomorrow() yang mengembalikan jumlah detik yang tersisa hingga esok hari.

Sebagai contoh, jika sekarang 23:00, maka:

getSecondsToTomorrow() == 3600

P.S. Fungsi haruslah berjalan untuk semua hari, sehingga ???hari ini??? tidak bisa dalam bentuk hard-code.

Untuk mendapatkan jumlah milidetik hingga besok, kita bisa mendapatkannya melalui pengurangan tanggal hari ini dengan ???besok 00:00:00???

Pertama, kita tentukan ???besok???, dan kemudian lakukan perhitungan:

function getSecondsToTomorrow() {
  let sekarang = new Date();

  // besok
  let besok = new Date(now.getFullYear(), now.getMonth(), now.getDate()+1);

  let beda = besok - sekarang; // beda dalam milidetik
  return Math.round(beda / 1000); // ubah ke detik
}

Solusi alternatif:

function getSecondsToTomorrow() {
  let sekarang = new Date();
  let jam = sekarang.getHours();
  let menit = sekarang.getMinutes();
  let detik = sekarang.getSeconds();
  let detikTotalHariIni = (jam * 60 + menit) * 60 + detik;
  let detikTotalDalamSatuHari = 86400;

  return detikTotalDalamSatuHari - detikTotalHariIni;
}

Harap diingat bahwa banyak negara menerapkan Daylight Savings Time (DST), sehingga memungkinkan ada hari dengan 23 atau 25 jam. Kita mungkin ingin melakukan perhitungan dengan cara yang berbeda untuk mereka.

Tulis sebuah fungsi formatDate(date) yang harus memformat date seperti berikut:

  • Jika sejak date lewat kurang dari 1 detik, lalu "sekarang".
  • Sebaliknya, jika sejak date lewat kurang dari satu menit, lalu "n detik yang lalu".
  • Sebaliknya, jika kurang dari satu jam, lalu "m menit yang lalu".
  • Sebaliknya, tanggal dalam format penuh "DD.MM.YY HH:mm". Itu adalah: "hari.bulan.tahun jam:menit", semua dalam format 2 angka, contoh. 31.12.16 10:00.

Contoh:

alert( formatDate(new Date(new Date - 1)) ); // "sekarang"

alert( formatDate(new Date(new Date - 30 * 1000)) ); // "30 detik yang lalu"

alert( formatDate(new Date(new Date - 5 * 60 * 1000)) ); // "5 menit yang lalu"

// tanggal kemarin seperti 31.12.16 20:00
alert( formatDate(new Date(new Date - 86400 * 1000)) );

Buka sandbox dengan tes.

Untuk mendapatkan waktu dari date sampai sekarang ??? kita kurangi tanggalnya.

function formatDate(date) {
  let diff = new Date() - date; // perbedaan dalam mili-detik

  if (diff < 1000) { // kurang dari 1 detik
    return 'right now';
  }

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

  if (sec < 60) {
    return sec + ' sec. ago';
  }

  let min = Math.floor(diff / 60000); // ubah diff menjadi menit
  if (min < 60) {
    return min + ' min. ago';
  }

  // format tanggalnya
  // tambahkan awalan nol ke dijit-tunggal hari/bulan/jam/menit
  let d = date;
  d = [
    '0' + d.getDate(),
    '0' + (d.getMonth() + 1),
    '' + d.getFullYear(),
    '0' + d.getHours(),
    '0' + d.getMinutes()
  ].map(component => component.slice(-2)); // ambil setidaknya 2 dijit dari setiap komponen

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

alert( formatDate(new Date(new Date - 1)) ); // "sekarang"

alert( formatDate(new Date(new Date - 30 * 1000)) ); // "30 detik yang lalu"

alert( formatDate(new Date(new Date - 5 * 60 * 1000)) ); // "5 menit yang lalu"

// tanggal kemarin seperti 31.12.2016 20:00
alert( formatDate(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;
  hour = hour < 10 ? '0' + hour : hour;
  minutes = minutes < 10 ? '0' + minutes : minutes;

  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}`
  }
}

Buka solusi dengan tes di sandbox.

Peta tutorial