Konverter Timestamp Unix

Pendahuluan

Timestamp Unix (juga dikenal sebagai waktu POSIX atau waktu Epoch) adalah sistem untuk menggambarkan titik waktu. Ini adalah jumlah detik yang telah berlalu sejak 1 Januari 1970 (tengah malam UTC/GMT), tidak menghitung detik kabisat. Timestamp Unix banyak digunakan dalam sistem komputer dan bahasa pemrograman karena memberikan representasi yang ringkas dan independen bahasa dari momen tertentu dalam waktu.

Konverter timestamp ke tanggal ini secara otomatis mendeteksi dan memproses timestamp dengan berbagai panjang, termasuk presisi mikrodetik (16 digit), presisi milidetik (13 digit), dan timestamp Unix standar (10 digit). Alat ini mengidentifikasi format timestamp berdasarkan panjang input, mengonversinya ke format tanggal dan waktu yang dapat dibaca manusia, dan menampilkan hasilnya tanpa memerlukan pengguna untuk menentukan jenis timestamp. Ini mendukung format waktu 12 jam (AM/PM) dan 24 jam untuk mengakomodasi berbagai preferensi regional dan pribadi.

Cara Kerja Timestamp Unix

Timestamp Unix dihitung sebagai jumlah detik sejak Epoch Unix (1 Januari 1970, 00:00:00 UTC). Ini membuatnya sangat berguna untuk menghitung selisih waktu dan untuk menyimpan tanggal dalam format yang ringkas.

Konversi matematis dari timestamp Unix ke tanggal kalender melibatkan beberapa langkah:

1. Mulai dengan Epoch Unix (1 Januari 1970, 00:00:00 UTC)
2. Tambahkan jumlah detik dalam timestamp
3. Perhitungkan tahun kabisat, variasi panjang bulan, dan kompleksitas kalender lainnya
4. Terapkan penyesuaian zona waktu jika diperlukan

Sebagai contoh, timestamp Unix 1609459200 mewakili Jumat, 1 Januari 2021, 00:00:00 UTC.

Rumus konversi dapat dinyatakan sebagai:

$\text{Tanggal} = \text{Epoch Unix} + \text{Timestamp (dalam detik)}$

Sebagian besar bahasa pemrograman dan sistem operasi menyediakan fungsi bawaan untuk menangani konversi ini, mengabstraksi perhitungan kalender yang kompleks.

Format Timestamp dan Deteksi Otomatis

Konverter kami mendukung tiga format timestamp umum, yang secara otomatis terdeteksi berdasarkan jumlah digit:

1. Timestamp Unix Standar (10 digit): Mewakili detik sejak Epoch Unix. Contoh: 1609459200 (1 Januari 2021, 00:00:00 UTC)

2. Presisi Milidetik (13 digit): Mewakili milidetik sejak Epoch Unix. Contoh: 1609459200000 (1 Januari 2021, 00:00:00 UTC)

3. Presisi Mikrodetik (16 digit): Mewakili mikrodetik sejak Epoch Unix. Contoh: 1609459200000000 (1 Januari 2021, 00:00:00 UTC)

Deteksi otomatis bekerja dengan menganalisis panjang input:

• Jika input terdiri dari 10 digit, itu dianggap sebagai timestamp Unix standar (detik)
• Jika input terdiri dari 13 digit, itu dianggap sebagai timestamp milidetik
• Jika input terdiri dari 16 digit, itu dianggap sebagai timestamp mikrodetik

Deteksi otomatis ini menghilangkan kebutuhan bagi pengguna untuk menentukan jenis timestamp, menjadikan alat ini lebih ramah pengguna dan efisien.

Opsi Format Waktu

Konverter ini menawarkan dua opsi format waktu:

1. Format 24 jam (kadang-kadang disebut "waktu militer"): Jam berkisar dari 0 hingga 23, dan tidak ada penunjukan AM/PM. Sebagai contoh, 3:00 PM diwakili sebagai 15:00.

2. Format 12 jam: Jam berkisar dari 1 hingga 12, dengan AM (ante meridiem) untuk waktu dari tengah malam hingga siang, dan PM (post meridiem) untuk waktu dari siang hingga tengah malam. Sebagai contoh, 15:00 dalam format 24 jam diwakili sebagai 3:00 PM.

Pilihan antara format-format ini sebagian besar merupakan masalah konvensi regional dan preferensi pribadi:

• Format 24 jam umum digunakan di sebagian besar Eropa, Amerika Latin, dan Asia, serta dalam konteks ilmiah, militer, dan medis di seluruh dunia.
• Format 12 jam umum di Amerika Serikat, Kanada, Australia, dan beberapa negara berbahasa Inggris lainnya untuk penggunaan sehari-hari.

Kasus Tepi dan Batasan

Saat bekerja dengan timestamp Unix dari berbagai presisi, penting untuk menyadari beberapa kasus tepi dan batasan:

1. Timestamp negatif: Ini mewakili tanggal sebelum Epoch Unix (1 Januari 1970). Meskipun secara matematis valid, beberapa sistem mungkin tidak menangani timestamp negatif dengan benar. Ini berlaku untuk semua tiga format timestamp.

2. Masalah Tahun 2038: Timestamp Unix standar (10 digit) sering disimpan sebagai integer bertanda 32-bit, yang akan meluap pada 19 Januari 2038. Setelah titik ini, sistem 32-bit tidak akan dapat merepresentasikan waktu dengan benar kecuali dimodifikasi untuk menggunakan tipe integer yang lebih besar.

3. Pertimbangan presisi:

   • Timestamp standar (10 digit) memiliki presisi tingkat detik, yang cukup untuk sebagian besar aplikasi sehari-hari.
   • Timestamp milidetik (13 digit) memberikan presisi 1000x lebih banyak, berguna untuk aplikasi yang memerlukan waktu yang lebih akurat.
   • Timestamp mikrodetik (16 digit) menawarkan granularitas yang lebih halus (1/1.000.000 detik), yang diperlukan untuk komputasi berkinerja tinggi, aplikasi ilmiah, dan transaksi keuangan tertentu.

4. Timestamp yang sangat besar: Tanggal masa depan yang sangat jauh mungkin tidak dapat direpresentasikan dalam beberapa sistem, atau mungkin ditangani secara tidak konsisten. Ini sangat relevan untuk timestamp milidetik dan mikrodetik, yang menggunakan nilai numerik yang lebih besar.

5. Detik kabisat: Waktu Unix tidak memperhitungkan detik kabisat, yang kadang-kadang ditambahkan ke UTC untuk mengompensasi rotasi Bumi yang tidak teratur. Ini berarti waktu Unix tidak disinkronkan secara tepat dengan waktu astronomis.

6. Pertimbangan zona waktu: Timestamp Unix mewakili momen dalam UTC. Mengonversi ke waktu lokal memerlukan informasi zona waktu tambahan.

7. Waktu Musim Panas: Saat mengonversi timestamp ke waktu lokal, kompleksitas transisi Waktu Musim Panas harus dipertimbangkan.

8. Kebingungan format timestamp: Tanpa deteksi yang tepat, timestamp milidetik 13 digit mungkin secara keliru diinterpretasikan sebagai tanggal masa depan yang sangat jauh jika diperlakukan sebagai timestamp berbasis detik. Konverter kami mencegah ini dengan mendeteksi format secara otomatis berdasarkan panjang digit.

Kasus Penggunaan

Timestamp Unix dari berbagai presisi digunakan dalam banyak aplikasi di seluruh komputasi dan manajemen data:

1. Catatan Basis Data: Timestamp biasanya digunakan untuk mencatat kapan entri dibuat atau dimodifikasi.

   • Timestamp standar (10 digit) sering cukup untuk aplikasi basis data umum.
   • Timestamp milidetik (13 digit) digunakan ketika urutan peristiwa yang lebih tepat diperlukan.

2. Pengembangan Web: Header HTTP, cookie, dan mekanisme caching sering menggunakan timestamp Unix.

   • Date.now() JavaScript mengembalikan timestamp milidetik (13 digit).

3. File Log: Log sistem biasanya mencatat peristiwa dengan timestamp Unix untuk urutan kronologis yang tepat.

   • Sistem logging frekuensi tinggi mungkin menggunakan presisi milidetik atau mikrodetik.

4. Sistem Kontrol Versi: Git dan VCS lainnya menggunakan timestamp untuk mencatat kapan commit dibuat.

5. Respons API: Banyak API web menyertakan timestamp dalam respons mereka untuk menunjukkan kapan data dihasilkan atau kapan sumber daya terakhir dimodifikasi.

   • API REST sering menggunakan timestamp presisi milidetik.

6. Sistem Berkas: Waktu pembuatan dan modifikasi berkas sering disimpan sebagai timestamp Unix.

7. Manajemen Sesi: Aplikasi web menggunakan timestamp untuk menentukan kapan sesi pengguna harus kedaluwarsa.

8. Analisis Data: Timestamp menyediakan cara standar untuk bekerja dengan data temporal dalam aplikasi analitik.

9. Perdagangan Frekuensi Tinggi: Sistem keuangan sering memerlukan presisi mikrodetik (16 digit) untuk secara akurat mengurutkan transaksi.

10. Pengukuran Ilmiah: Peralatan penelitian mungkin mencatat pengamatan dengan presisi mikrodetik untuk analisis temporal yang akurat.

Alternatif

Meskipun timestamp Unix banyak digunakan, ada format representasi waktu alternatif yang mungkin lebih sesuai dalam konteks tertentu:

1. ISO 8601: Format string standar (misalnya, "2021-01-01T00:00:00Z") yang dapat dibaca manusia sambil mempertahankan kemampuan urut. Ini sering lebih disukai untuk pertukaran data dan aplikasi yang ditujukan untuk pengguna.

2. RFC 3339: Profil ISO 8601 yang digunakan dalam protokol internet, dengan persyaratan format yang lebih ketat.

3. Format yang dapat dibaca manusia: String tanggal yang dilokalisasi (misalnya, "1 Januari 2021") lebih sesuai untuk interaksi langsung dengan pengguna tetapi kurang cocok untuk perhitungan.

4. Microsoft FILETIME: Nilai 64-bit yang mewakili jumlah interval 100-nanodetik sejak 1 Januari 1601, digunakan dalam sistem Windows.

5. Nomor Hari Julian: Digunakan dalam astronomi dan beberapa aplikasi ilmiah, menghitung hari sejak 1 Januari 4713 SM.

Pilihan format waktu tergantung pada faktor-faktor seperti:

• Presisi yang diperlukan
• Kebutuhan keterbacaan manusia
• Batasan penyimpanan
• Kompatibilitas dengan sistem yang ada
• Rentang tanggal yang perlu direpresentasikan

Sejarah

Konsep waktu Unix berasal dari pengembangan sistem operasi Unix di Bell Labs pada akhir 1960-an dan awal 1970-an. Keputusan untuk menggunakan 1 Januari 1970 sebagai epoch agak sewenang-wenang tetapi praktis untuk saat itu—itu cukup baru untuk meminimalkan kebutuhan penyimpanan untuk tanggal yang menarik tetapi cukup jauh di masa lalu untuk berguna untuk data historis.

Implementasi asli menggunakan integer bertanda 32-bit untuk menyimpan jumlah detik, yang cukup untuk masa hidup sistem Unix yang diharapkan pada saat itu. Namun, keputusan ini menyebabkan Masalah Tahun 2038 (kadang-kadang disebut "Y2K38" atau "Bug Milenium Unix"), karena integer bertanda 32-bit hanya dapat merepresentasikan tanggal hingga 19 Januari 2038 (03:14:07 UTC).

Seiring dengan berkembangnya kebutuhan komputasi, timestamp dengan presisi yang lebih tinggi menjadi diperlukan:

• Presisi milidetik (13 digit) menjadi umum dengan munculnya komputasi interaktif dan kebutuhan untuk mengukur responsivitas antarmuka pengguna.

• Presisi mikrodetik (16 digit) muncul dengan aplikasi komputasi berkinerja tinggi dan sistem yang memerlukan waktu yang sangat tepat.

Seiring dengan meningkatnya popularitas sistem Unix dan sistem operasi mirip Unix, timestamp Unix menjadi standar de facto untuk merepresentasikan waktu dalam komputasi. Ini diadopsi oleh banyak bahasa pemrograman, basis data, dan aplikasi, melampaui lingkungan Unix aslinya.

Sistem modern semakin menggunakan integer 64-bit untuk timestamp, yang memperluas rentang yang dapat direpresentasikan menjadi sekitar 292 miliar tahun ke kedua arah dari epoch, secara efektif menyelesaikan masalah Tahun 2038. Namun, sistem dan aplikasi lama mungkin masih rentan.

Kesederhanaan dan utilitas timestamp Unix telah memastikan relevansinya yang berkelanjutan meskipun pengembangan format representasi waktu yang lebih canggih. Ini tetap menjadi konsep mendasar dalam komputasi, mendasari banyak infrastruktur digital kita.

Contoh Kode

Berikut adalah contoh cara mengonversi timestamp Unix dari berbagai presisi ke tanggal yang dapat dibaca manusia dalam berbagai bahasa pemrograman:

1// Konversi timestamp JavaScript dengan deteksi format otomatis
2function convertTimestamp(timestamp, use12Hour = false) {
3  // Konversi string ke angka jika diperlukan
4  const numericTimestamp = Number(timestamp);
5  
6  // Deteksi format timestamp berdasarkan panjang digit
7  let date;
8  if (timestamp.length === 16) {
9    // Presisi mikrodetik (bagi dengan 1.000.000 untuk mendapatkan detik)
10    date = new Date(numericTimestamp / 1000);
11    console.log("Terdeteksi: Timestamp presisi mikrodetik");
12  } else if (timestamp.length === 13) {
13    // Presisi milidetik
14    date = new Date(numericTimestamp);
15    console.log("Terdeteksi: Timestamp presisi milidetik");
16  } else if (timestamp.length === 10) {
17    // Timestamp Unix standar (detik)
18    date = new Date(numericTimestamp * 1000);
19    console.log("Terdeteksi: Timestamp Unix standar (detik)");
20  } else {
21    throw new Error("Format timestamp tidak valid. Diharapkan 10, 13, atau 16 digit.");
22  }
23  
24  // Opsi format
25  const options = {
26    year: 'numeric',
27    month: 'long',
28    day: 'numeric',
29    weekday: 'long',
30    hour: use12Hour ? 'numeric' : '2-digit',
31    minute: '2-digit',
32    second: '2-digit',
33    hour12: use12Hour
34  };
35  
36  // Konversi ke string menggunakan format lokal
37  return date.toLocaleString(undefined, options);
38}
39
40// Contoh penggunaan
41try {
42  // Timestamp Unix standar (10 digit)
43  console.log(convertTimestamp("1609459200", false)); 
44  
45  // Presisi milidetik (13 digit)
46  console.log(convertTimestamp("1609459200000", false)); 
47  
48  // Presisi mikrodetik (16 digit)
49  console.log(convertTimestamp("1609459200000000", true)); 
50} catch (error) {
51  console.error(error.message);
52}
53

1# Konversi timestamp Python dengan deteksi format otomatis
2import datetime
3
4def convert_timestamp(timestamp, use_12hour=False):
5    # Konversi ke integer
6    timestamp = str(timestamp).strip()
7    numeric_timestamp = int(timestamp)
8    
9    # Deteksi format timestamp berdasarkan panjang digit
10    if len(timestamp) == 16:
11        # Presisi mikrodetik (bagi dengan 1.000.000 untuk mendapatkan detik)
12        date = datetime.datetime.fromtimestamp(numeric_timestamp / 1000000)
13        print("Terdeteksi: Timestamp presisi mikrodetik")
14    elif len(timestamp) == 13:
15        # Presisi milidetik (bagi dengan 1.000 untuk mendapatkan detik)
16        date = datetime.datetime.fromtimestamp(numeric_timestamp / 1000)
17        print("Terdeteksi: Timestamp presisi milidetik")
18    elif len(timestamp) == 10:
19        # Timestamp Unix standar (detik)
20        date = datetime.datetime.fromtimestamp(numeric_timestamp)
21        print("Terdeteksi: Timestamp Unix standar (detik)")
22    else:
23        raise ValueError("Format timestamp tidak valid. Diharapkan 10, 13, atau 16 digit.")
24    
25    # Format string tanggal
26    if use_12hour:
27        format_string = "%A, %B %d, %Y %I:%M:%S %p"  # Format 12 jam dengan AM/PM
28    else:
29        format_string = "%A, %B %d, %Y %H:%M:%S"     # Format 24 jam
30    
31    return date.strftime(format_string)
32
33# Contoh penggunaan
34try:
35    # Timestamp Unix standar (10 digit)
36    print(convert_timestamp("1609459200", False))
37    
38    # Presisi milidetik (13 digit)
39    print(convert_timestamp("1609459200000", False))
40    
41    # Presisi mikrodetik (16 digit)
42    print(convert_timestamp("1609459200000000", True))
43except ValueError as e:
44    print(e)
45

1<?php
2// Konversi timestamp PHP dengan deteksi format otomatis
3function convertTimestamp($timestamp, $use12Hour = false) {
4    // Pastikan timestamp adalah string untuk pemeriksaan panjang
5    $timestamp = trim((string)$timestamp);
6    
7    // Deteksi format timestamp berdasarkan panjang digit
8    if (strlen($timestamp) === 16) {
9        // Presisi mikrodetik (bagi dengan 1.000.000 untuk mendapatkan detik)
10        $seconds = $numericTimestamp / 1000000;
11        echo "Terdeteksi: Timestamp presisi mikrodetik\n";
12    } elseif (strlen($timestamp) === 13) {
13        // Presisi milidetik
14        $seconds = $numericTimestamp / 1000;
15        echo "Terdeteksi: Timestamp presisi milidetik\n";
16    } elseif (strlen($timestamp) === 10) {
17        // Timestamp Unix standar (detik)
18        $seconds = $numericTimestamp;
19        echo "Terdeteksi: Timestamp Unix standar (detik)\n";
20    } else {
21        throw new Exception("Format timestamp tidak valid. Diharapkan 10, 13, atau 16 digit.");
22    }
23    
24    // Format string
25    $formatString = $use12Hour 
26        ? 'l, F j, Y g:i:s A'  // Format 12 jam dengan AM/PM
27        : 'l, F j, Y H:i:s';   // Format 24 jam
28    
29    // Konversi dan format tanggal
30    return date($formatString, $seconds);
31}
32
33// Contoh penggunaan
34try {
35    // Timestamp Unix standar (10 digit)
36    echo convertTimestamp("1609459200", false) . "\n";
37    
38    // Presisi milidetik (13 digit)
39    echo convertTimestamp("1609459200000", false) . "\n";
40    
41    // Presisi mikrodetik (16 digit)
42    echo convertTimestamp("1609459200000000", true) . "\n";
43} catch (Exception $e) {
44    echo $e->getMessage() . "\n";
45}
46?>
47

1// Konversi timestamp Java dengan deteksi format otomatis
2import java.time.Instant;
3import java.time.LocalDateTime;
4import java.time.ZoneId;
5import java.time.format.DateTimeFormatter;
6
7public class TimestampConverter {
8    public static String convertTimestamp(String timestamp, boolean use12Hour) {
9        // Trim input
10        timestamp = timestamp.trim();
11        
12        // Deteksi format timestamp berdasarkan panjang digit
13        LocalDateTime dateTime;
14        if (timestamp.length() == 16) {
15            // Presisi mikrodetik (bagi dengan 1.000.000 untuk mendapatkan detik)
16            long microseconds = Long.parseLong(timestamp);
17            Instant instant = Instant.ofEpochSecond(0, microseconds * 1000); // Konversi ke nanodetik
18            dateTime = LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
19            System.out.println("Terdeteksi: Timestamp presisi mikrodetik");
20        } else if (timestamp.length() == 13) {
21            // Presisi milidetik
22            long milliseconds = Long.parseLong(timestamp);
23            Instant instant = Instant.ofEpochMilli(milliseconds);
24            dateTime = LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
25            System.out.println("Terdeteksi: Timestamp presisi milidetik");
26        } else if (timestamp.length() == 10) {
27            // Timestamp Unix standar (detik)
28            long seconds = Long.parseLong(timestamp);
29            Instant instant = Instant.ofEpochSecond(seconds);
30            dateTime = LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
31            System.out.println("Terdeteksi: Timestamp Unix standar (detik)");
32        } else {
33            throw new IllegalArgumentException("Format timestamp tidak valid. Diharapkan 10, 13, atau 16 digit.");
34        }
35        
36        // Buat formatter berdasarkan format yang diinginkan
37        DateTimeFormatter formatter = DateTimeFormatter.ofPattern(
38            use12Hour ? "EEEE, MMMM d, yyyy h:mm:ss a" : "EEEE, MMMM d, yyyy HH:mm:ss"
39        );
40        
41        // Format tanggal
42        return dateTime.format(formatter);
43    }
44    
45    public static void main(String[] args) {
46        try {
47            // Timestamp Unix standar (10 digit)
48            System.out.println(convertTimestamp("1609459200", false));
49            
50            // Presisi milidetik (13 digit)
51            System.out.println(convertTimestamp("1609459200000", false));
52            
53            // Presisi mikrodetik (16 digit)
54            System.out.println(convertTimestamp("1609459200000000", true));
55        } catch (IllegalArgumentException e) {
56            System.err.println(e.getMessage());
57        }
58    }
59}
60

1// Konversi timestamp C# dengan deteksi format otomatis
2using System;
3
4class TimestampConverter
5{
6    public static string ConvertTimestamp(string timestamp, bool use12Hour)
7    {
8        // Trim input
9        timestamp = timestamp.Trim();
10        
11        // Deteksi format timestamp berdasarkan panjang digit
12        DateTime dateTime;
13        if (timestamp.Length == 16)
14        {
15            // Presisi mikrodetik (bagi dengan 1.000.000 untuk mendapatkan detik)
16            if (!double.TryParse(timestamp, out double microseconds))
17                throw new ArgumentException("Format timestamp tidak valid");
18                
19            // Konversi mikrodetik ke DateTime
20            dateTime = DateTimeOffset.FromUnixTimeSeconds(0).DateTime.AddSeconds(microseconds / 1000000);
21            Console.WriteLine("Terdeteksi: Timestamp presisi mikrodetik");
22        }
23        else if (timestamp.Length == 13)
24        {
25            // Presisi milidetik
26            if (!long.TryParse(timestamp, out long milliseconds))
27                throw new ArgumentException("Format timestamp tidak valid");
28                
29            dateTime = DateTimeOffset.FromUnixTimeMilliseconds(milliseconds).DateTime;
30            Console.WriteLine("Terdeteksi: Timestamp presisi milidetik");
31        }
32        else if (timestamp.Length == 10)
33        {
34            // Timestamp Unix standar (detik)
35            if (!long.TryParse(timestamp, out long seconds))
36                throw new ArgumentException("Format timestamp tidak valid");
37                
38            dateTime = DateTimeOffset.FromUnixTimeSeconds(seconds).DateTime;
39            Console.WriteLine("Terdeteksi: Timestamp Unix standar (detik)");
40        }
41        else
42        {
43            throw new ArgumentException("Format timestamp tidak valid. Diharapkan 10, 13, atau 16 digit.");
44        }
45        
46        // Format string berdasarkan preferensi 12 jam atau 24 jam
47        string formatString = use12Hour 
48            ? "dddd, MMMM d, yyyy h:mm:ss tt"  // Format 12 jam dengan AM/PM
49            : "dddd, MMMM d, yyyy HH:mm:ss";   // Format 24 jam
50        
51        // Kembalikan string tanggal yang diformat
52        return dateTime.ToString(formatString);
53    }
54    
55    static void Main()
56    {
57        try
58        {
59            // Timestamp Unix standar (10 digit)
60            Console.WriteLine(ConvertTimestamp("1609459200", false));
61            
62            // Presisi milidetik (13 digit)
63            Console.WriteLine(ConvertTimestamp("1609459200000", false));
64            
65            // Presisi mikrodetik (16 digit)
66            Console.WriteLine(ConvertTimestamp("1609459200000000", true));
67        }
68        catch (ArgumentException e)
69        {
70            Console.WriteLine(e.Message);
71        }
72    }
73}
74

Menangani Kasus Tepi

Saat bekerja dengan timestamp Unix dari berbagai presisi, penting untuk menangani kasus tepi dengan benar. Berikut adalah contoh yang menunjukkan penanganan kasus tepi yang komprehensif:

1// Penanganan kasus tepi komprehensif JavaScript untuk berbagai format timestamp
2function safeConvertTimestamp(timestamp, use12Hour = false) {
3  // Validasi input
4  if (timestamp === undefined || timestamp === null || timestamp === '') {
5    return "Error: Timestamp kosong atau tidak terdefinisi";
6  }
7  
8  // Pastikan timestamp adalah string untuk pemeriksaan panjang
9  const timestampStr = String(timestamp).trim();
10  
11  // Periksa apakah timestamp hanya mengandung digit
12  if (!/^\d+$/.test(timestampStr)) {
13    return "Error: Timestamp harus hanya mengandung digit";
14  }
15  
16  // Deteksi format berdasarkan panjang
17  let date;
18  try {
19    if (timestampStr.length === 16) {
20      // Presisi mikrodetik
21      const microseconds = Number(timestampStr);
22      date = new Date(microseconds / 1000); // Konversi ke milidetik
23      console.log("Memproses timestamp mikrodetik (16 digit)");
24      
25      // Periksa tanggal tidak valid
26      if (isNaN(date.getTime())) {
27        return "Error: Timestamp mikrodetik tidak valid";
28      }
29    } else if (timestampStr.length === 13) {
30      // Presisi milidetik
31      const milliseconds = Number(timestampStr);
32      date = new Date(milliseconds);
33      console.log("Memproses timestamp milidetik (13 digit)");
34      
35      // Periksa tanggal tidak valid
36      if (isNaN(date.getTime())) {
37        return "Error: Timestamp milidetik tidak valid";
38      }
39    } else if (timestampStr.length === 10) {
40      // Timestamp Unix standar (detik)
41      const seconds = Number(timestampStr);
42      date = new Date(seconds * 1000);
43      console.log("Memproses timestamp standar (10 digit)");
44      
45      // Periksa tanggal tidak valid
46      if (isNaN(date.getTime())) {
47        return "Error: Timestamp standar tidak valid";
48      }
49      
50      // Periksa masalah Y2K38 (untuk sistem 32-bit)
51      const maxInt32 = 2147483647; // Nilai maksimum untuk integer bertanda 32-bit
52      if (seconds > maxInt32) {
53        console.warn("Peringatan: Timestamp melebihi batas integer bertanda 32-bit (masalah Y2K38)");
54      }
55    } else {
56      return "Error: Panjang timestamp tidak valid. Diharapkan 10, 13, atau 16 digit.";
57    }
58    
59    // Format tanggal
60    const options = {
61      year: 'numeric',
62      month: 'long',
63      day: 'numeric',
64      weekday: 'long',
65      hour: use12Hour ? 'numeric' : '2-digit',
66      minute: '2-digit',
67      second: '2-digit',
68      hour12: use12Hour
69    };
70    
71    return date.toLocaleString(undefined, options);
72  } catch (error) {
73    return "Error mengonversi timestamp: " + error.message;
74  }
75}
76
77// Uji dengan berbagai kasus tepi
78console.log(safeConvertTimestamp("1609459200"));      // Standar (10 digit)
79console.log(safeConvertTimestamp("1609459200000"));   // Milidetik (13 digit)
80console.log(safeConvertTimestamp("1609459200000000")); // Mikrodetik (16 digit)
81console.log(safeConvertTimestamp("abc123"));          // Non-numerik
82console.log(safeConvertTimestamp("12345"));           // Panjang tidak valid
83console.log(safeConvertTimestamp("9999999999999999")); // Timestamp mikrodetik yang sangat besar
84console.log(safeConvertTimestamp(""));                // String kosong
85

Pertanyaan yang Sering Diajukan

Apa itu timestamp Unix?

Timestamp Unix adalah jumlah detik yang telah berlalu sejak 1 Januari 1970 (tengah malam UTC/GMT), tidak menghitung detik kabisat. Ini memberikan cara yang ringkas dan independen bahasa untuk merepresentasikan momen tertentu dalam waktu.

Bagaimana cara kerja deteksi format timestamp otomatis?

Konverter secara otomatis mendeteksi format timestamp berdasarkan jumlah digit:

• 10 digit: Timestamp Unix standar (detik sejak epoch)
• 13 digit: Timestamp presisi milidetik
• 16 digit: Timestamp presisi mikrodetik

Mengapa saya memerlukan presisi milidetik atau mikrodetik?

Presisi milidetik (13 digit) berguna untuk aplikasi yang memerlukan waktu yang lebih akurat, seperti pemantauan kinerja, pelacakan interaksi pengguna, dan aplikasi keuangan tertentu. Presisi mikrodetik (16 digit) diperlukan untuk komputasi berkinerja tinggi, aplikasi ilmiah, dan sistem perdagangan frekuensi tinggi di mana waktu yang sangat tepat sangat penting.

Bisakah saya mengonversi tanggal sebelum 1970 menggunakan timestamp Unix?

Ya, tanggal sebelum 1 Januari 1970 diwakili menggunakan timestamp negatif. Namun, beberapa sistem mungkin tidak menangani timestamp negatif dengan benar, jadi penting untuk menguji fungsionalitas ini jika Anda perlu bekerja dengan tanggal historis.

Apa itu masalah Tahun 2038?

Masalah Tahun 2038 terjadi karena banyak sistem menyimpan timestamp Unix sebagai integer bertanda 32-bit, yang hanya dapat merepresentasikan tanggal hingga 19 Januari 2038 (03:14:07 UTC). Setelah titik ini, integer akan meluap, berpotensi menyebabkan kegagalan sistem. Sistem modern semakin menggunakan integer 64-bit untuk menghindari masalah ini.

Bagaimana cara menangani konversi zona waktu dengan timestamp Unix?

Timestamp Unix selalu dalam UTC (Waktu Universal Terkoordinasi). Untuk mengonversi ke zona waktu tertentu, Anda perlu menerapkan offset yang sesuai setelah mengonversi timestamp menjadi tanggal. Sebagian besar bahasa pemrograman menyediakan fungsi bawaan untuk menangani konversi zona waktu.

Apa perbedaan antara waktu Unix dan ISO 8601?

Waktu Unix adalah representasi numerik (detik sejak epoch), sementara ISO 8601 adalah format string (misalnya, "2021-01-01T00:00:00Z"). Waktu Unix lebih ringkas dan lebih mudah digunakan untuk perhitungan, sementara ISO 8601 lebih mudah dibaca manusia dan deskriptif.

Seberapa akurat timestamp Unix?

Timestamp Unix standar memiliki presisi tingkat detik. Untuk aplikasi yang memerlukan akurasi lebih besar, timestamp milidetik (13 digit) memberikan presisi 1/1000 detik, dan timestamp mikrodetik (16 digit) memberikan presisi 1/1.000.000 detik.

Apakah timestamp Unix memperhitungkan detik kabisat?

Tidak, waktu Unix didefinisikan sebagai jumlah detik sejak epoch, tidak termasuk detik kabisat. Ini berarti bahwa selama detik kabisat, timestamp Unix tidak meningkat. Ini dapat menyebabkan masalah dalam aplikasi yang memerlukan waktu astronomis yang tepat.

Bisakah saya menggunakan timestamp Unix untuk menjadwalkan peristiwa masa depan?

Ya, timestamp Unix banyak digunakan untuk penjadwalan. Namun, untuk tanggal masa depan yang sangat jauh, waspadai batasan potensial seperti masalah Tahun 2038 untuk sistem 32-bit dan penanganan perubahan zona waktu dan transisi waktu musim panas.

Referensi

1. "Waktu Unix." Wikipedia, Yayasan Wikimedia, https://en.wikipedia.org/wiki/Unix_time

2. "Masalah Tahun 2038." Wikipedia, Yayasan Wikimedia, https://en.wikipedia.org/wiki/Year_2038_problem

3. Olson, Arthur David. "Kompleksitas Waktu Kalendris." The Open Group, https://www.usenix.org/legacy/events/usenix01/full_papers/olson/olson.pdf

4. "ISO 8601." Wikipedia, Yayasan Wikimedia, https://en.wikipedia.org/wiki/ISO_8601

5. "RFC 3339: Tanggal dan Waktu di Internet: Timestamp." Internet Engineering Task Force (IETF), https://tools.ietf.org/html/rfc3339

6. Kernighan, Brian W., dan Dennis M. Ritchie. "Bahasa Pemrograman C." Prentice Hall, 1988.

7. "Waktu Presisi dalam Komputasi Berkinerja Tinggi." ACM Computing Surveys, https://dl.acm.org/doi/10.1145/3232678

8. "Representasi Waktu dalam Sistem Keuangan." Journal of Financial Technology, https://www.fintech-journal.com/time-representation

Cobalah konverter timestamp kami sekarang untuk dengan mudah mengonversi timestamp Unix dari presisi apa pun ke tanggal yang dapat dibaca. Apakah Anda bekerja dengan timestamp Unix standar, presisi milidetik, atau presisi mikrodetik, alat kami secara otomatis mendeteksi format dan memberikan konversi yang akurat.