Unix Zaman Damgası Dönüştürücü

Giriş

Unix zaman damgası (POSIX zamanı veya Epoch zamanı olarak da bilinir), bir zaman noktasını tanımlamak için bir sistemdir. 1 Ocak 1970'ten (orta gece UTC/GMT) itibaren geçen saniye sayısıdır; artık saniyeleri saymaz. Unix zaman damgaları, belirli bir zaman anını temsil eden dil bağımsız, kompakt bir gösterim sağladığı için bilgisayar sistemlerinde ve programlama dillerinde yaygın olarak kullanılmaktadır.

Bu zaman damgasından tarihe dönüştürücü, mikro saniye hassasiyeti (16 haneli), milisaniye hassasiyeti (13 haneli) ve standart Unix zaman damgaları (10 haneli) dahil olmak üzere çeşitli uzunluklardaki zaman damgalarını otomatik olarak algılar ve işler. Araç, girdi uzunluğuna dayanarak zaman damgası formatını tanımlar, bunu insan tarafından okunabilir bir tarih ve saat formatına dönüştürür ve kullanıcıların zaman damgası türünü belirtmesini gerektirmeden sonucu görüntüler. Farklı bölgesel ve kişisel tercihlere uyum sağlamak için hem 12 saatlik (AM/PM) hem de 24 saatlik zaman formatlarını destekler.

Unix Zaman Damgalarının Çalışma Şekli

Unix zaman damgaları, Unix Epoch'undan (1 Ocak 1970, 00:00:00 UTC) itibaren geçen saniye sayısı olarak hesaplanır. Bu, zaman farklarını hesaplamak ve tarihleri kompakt bir formatta saklamak için özellikle kullanışlıdır.

Bir Unix zaman damgasından takvim tarihine dönüşüm matematiksel olarak birkaç adım içerir:

1. Unix Epoch'u (1 Ocak 1970, 00:00:00 UTC) ile başlayın
2. Zaman damgasındaki saniye sayısını ekleyin
3. Artık yıllar, değişken ay uzunlukları ve diğer takvim karmaşıklıklarını dikkate alın
4. Gerekirse zaman dilimi ayarlamalarını uygulayın

Örneğin, Unix zaman damgası 1609459200, 1 Ocak 2021 Cuma, 00:00:00 UTC'yi temsil eder.

Dönüşüm formülü şu şekilde ifade edilebilir:

$\text{Tarih} = \text{Unix Epoch} + \text{Zaman Damgası (saniye cinsinden)}$

Çoğu programlama dili ve işletim sistemi, bu dönüşümü yönetmek için yerleşik işlevler sağlar, karmaşık takvim hesaplamalarını soyutlayarak.

Zaman Damgası Formatları ve Otomatik Algılama

Dönüştürücümüz, hanelerine göre otomatik olarak algılanan üç yaygın zaman damgası formatını destekler:

1. Standart Unix Zaman Damgası (10 haneli): Unix Epoch'tan itibaren geçen saniyeleri temsil eder. Örnek: 1609459200 (1 Ocak 2021, 00:00:00 UTC)

2. Milisaniye Hassasiyeti (13 haneli): Unix Epoch'tan itibaren geçen milisaniyeleri temsil eder. Örnek: 1609459200000 (1 Ocak 2021, 00:00:00 UTC)

3. Mikrosaniye Hassasiyeti (16 haneli): Unix Epoch'tan itibaren geçen mikrosaniyeleri temsil eder. Örnek: 1609459200000000 (1 Ocak 2021, 00:00:00 UTC)

Otomatik algılama, girdinin uzunluğunu analiz ederek çalışır:

• Girdi 10 haneli ise, standart Unix zaman damgası (saniye) olarak kabul edilir
• Girdi 13 haneli ise, milisaniye zaman damgası olarak kabul edilir
• Girdi 16 haneli ise, mikrosaniye zaman damgası olarak kabul edilir

Bu otomatik algılama, kullanıcıların zaman damgası türünü belirtme gereksinimini ortadan kaldırarak aracı daha kullanıcı dostu ve verimli hale getirir.

Zaman Formatı Seçenekleri

Bu dönüştürücü, iki zaman formatı seçeneği sunar:

1. 24 saat formatı (bazen "askeri zaman" olarak adlandırılır): Saatler 0'dan 23'e kadar değişir ve AM/PM belirtimi yoktur. Örneğin, 15:00, 3:00 PM olarak temsil edilir.

2. 12 saat formatı: Saatler 1'den 12'ye kadar değişir, AM (ante meridiem) gece yarısından öğlene kadar olan zamanlar için, PM (post meridiem) ise öğleden sonra ve gece yarısından sonraki zamanlar için kullanılır. Örneğin, 24 saat formatındaki 15:00, 3:00 PM olarak temsil edilir.

Bu formatlar arasındaki seçim büyük ölçüde bölgesel gelenek ve kişisel tercihlere bağlıdır:

• 24 saat formatı, çoğu Avrupa, Latin Amerika ve Asya'nın yanı sıra bilimsel, askeri ve tıbbi bağlamlarda dünya genelinde yaygın olarak kullanılmaktadır.
• 12 saat formatı, Amerika Birleşik Devletleri, Kanada, Avustralya ve bazı diğer İngilizce konuşan ülkelerde günlük kullanımda yaygındır.

Kenar Durumları ve Sınırlamalar

Farklı hassasiyetlerdeki Unix zaman damgaları ile çalışırken, birkaç kenar durumu ve sınırlama hakkında bilgi sahibi olmak önemlidir:

1. Negatif zaman damgaları: Bunlar, Unix Epoch'tan (1 Ocak 1970) önceki tarihleri temsil eder. Matematiksel olarak geçerli olmalarına rağmen, bazı sistemler negatif zaman damgalarını doğru bir şekilde işleyemeyebilir. Bu, üç zaman damgası formatının tümü için geçerlidir.

2. Yıl 2038 Sorunu: Standart Unix zaman damgaları (10 haneli) genellikle 32 bit işaretli tamsayılar olarak saklanır ve bu, 19 Ocak 2038'de taşma yapacaktır. Bu tarihten sonra, 32 bit sistemler doğru zamanları temsil edemeyeceklerdir, aksi takdirde daha büyük bir tamsayı türü kullanılarak değiştirilmedikçe.

3. Hassasiyet dikkate alımları:

   • Standart zaman damgaları (10 haneli), çoğu günlük uygulama için yeterli olan saniye düzeyinde hassasiyete sahiptir.
   • Milisaniye zaman damgaları (13 haneli), daha doğru zamanlama gerektiren uygulamalar için kullanışlıdır.
   • Mikrosaniye zaman damgaları (16 haneli), yüksek performanslı bilgisayarlar, bilimsel uygulamalar ve belirli finansal işlemler için gerekli olan daha ince ayrıntılı zamanlama sunar.

4. Son derece büyük zaman damgaları: Çok uzak gelecekteki tarihler bazı sistemlerde temsil edilemeyebilir veya tutarsız bir şekilde işlenebilir. Bu, özellikle daha büyük sayısal değerler kullanan milisaniye ve mikrosaniye zaman damgaları için geçerlidir.

5. Artık saniyeler: Unix zamanı, Dünya'nın düzensiz dönüşünü telafi etmek için UTC'ye zaman zaman eklenen artık saniyeleri hesaba katmaz. Bu, Unix zamanının astronomik zamanla tam olarak senkronize olmadığı anlamına gelir.

6. Zaman dilimi dikkate alımları: Unix zaman damgaları, UTC'deki anları temsil eder. Yerel zamana dönüştürmek, ek zaman dilimi bilgisi gerektirir.

7. Yaz Saati Uygulaması: Zaman damgalarını yerel zamana dönüştürürken, Yaz Saati Uygulaması geçişlerinin karmaşıklıkları dikkate alınmalıdır.

8. Zaman damgası formatı karışıklığı: Doğru algılama olmadan, 13 haneli bir milisaniye zaman damgası, saniye bazında bir zaman damgası olarak ele alındığında çok uzak bir gelecekteki tarih olarak yanlış yorumlanabilir. Dönüştürücümüz, hane uzunluğuna dayanarak formatı otomatik olarak algılayarak bunu önler.

Kullanım Durumları

Farklı hassasiyetlerdeki Unix zaman damgaları, bilgisayar ve veri yönetimi uygulamalarında yaygın olarak kullanılmaktadır:

1. Veritabanı Kayıtları: Zaman damgaları, genellikle girişlerin ne zaman oluşturulduğunu veya değiştirildiğini kaydetmek için kullanılır.

   • Standart zaman damgaları (10 haneli), genel veritabanı uygulamaları için genellikle yeterlidir.
   • Milisaniye zaman damgaları (13 haneli), olayların daha doğru bir şekilde sıralanması gerektiğinde kullanılır.

2. Web Geliştirme: HTTP başlıkları, çerezler ve önbellekleme mekanizmaları genellikle Unix zaman damgalarını kullanır.

   • JavaScript'in Date.now() işlevi milisaniye zaman damgalarını (13 haneli) döndürür.

3. Günlük Dosyaları: Sistem günlükleri, olayları kesin kronolojik sıralama ile kaydetmek için genellikle Unix zaman damgaları ile kaydedilir.

   • Yüksek frekanslı günlükleme sistemleri milisaniye veya mikrosaniye hassasiyetini kullanabilir.

4. Versiyon Kontrol Sistemleri: Git ve diğer VCS'ler, ne zaman taahhüt yapıldığını kaydetmek için zaman damgalarını kullanır.

5. API Yanıtları: Birçok web API'si, verilerin ne zaman oluşturulduğunu veya kaynakların en son ne zaman değiştirildiğini belirtmek için yanıtlarında zaman damgaları içerir.

   • REST API'leri genellikle milisaniye hassasiyetinde zaman damgaları kullanır.

6. Dosya Sistemleri: Dosya oluşturma ve değiştirme zamanları genellikle Unix zaman damgaları olarak saklanır.

7. Oturum Yönetimi: Web uygulamaları, kullanıcı oturumlarının ne zaman sona ereceğini belirlemek için zaman damgalarını kullanır.

8. Veri Analizi: Zaman damgaları, analiz uygulamalarında zamansal verilerle çalışmanın standart bir yolunu sağlar.

9. Yüksek Frekanslı Ticaret: Finansal sistemler, işlemleri doğru bir şekilde sıralamak için genellikle mikrosaniye hassasiyetine (16 haneli) ihtiyaç duyar.

10. Bilimsel Ölçümler: Araştırma ekipmanları, kesin zamansal analiz için mikrosaniye hassasiyeti ile gözlemleri kaydedebilir.

Alternatifler

Unix zaman damgaları yaygın olarak kullanılsa da, belirli bağlamlarda daha uygun olabilecek alternatif zaman temsil formatları vardır:

1. ISO 8601: İnsan tarafından okunabilirken sıralanabilirliği koruyan standart bir dize formatıdır (örneğin, "2021-01-01T00:00:00Z"). Veri alışverişi ve kullanıcıya yönelik uygulamalar için sıklıkla tercih edilir.

2. RFC 3339: İnternet protokollerinde kullanılan ISO 8601'in bir profili olup, daha katı biçimlendirme gereksinimlerine sahiptir.

3. İnsan tarafından okunabilir formatlar: Yerelleştirilmiş tarih dizeleri (örneğin, "1 Ocak 2021") doğrudan kullanıcı etkileşimi için daha uygunken, hesaplama için daha az uygundur.

4. Microsoft FILETIME: 1 Ocak 1601'den itibaren geçen 100 nanosaniye aralıklarını temsil eden 64 bit bir değerdir ve Windows sistemlerinde kullanılır.

5. Jülyen Gün Sayısı: Astronomi ve bazı bilimsel uygulamalarda kullanılan, M.Ö. 4713'ten itibaren günleri sayan bir sistemdir.

Zaman formatı seçimi, aşağıdaki gibi faktörlere bağlıdır:

• Gerekli hassasiyet
• İnsan okunabilirlik ihtiyaçları
• Depolama kısıtlamaları
• Mevcut sistemlerle uyumluluk
• Temsil edilmesi gereken tarih aralığı

Tarihçe

Unix zaman kavramı, 1960'ların sonları ve 1970'lerin başlarında Bell Labs'ta Unix işletim sisteminin geliştirilmesiyle ortaya çıktı. Epoch olarak 1 Ocak 1970'i kullanma kararı, o dönemde pratik bir seçimdi; ilgi çekici tarihler için depolama gereksinimlerini en aza indirmek için yeterince yakın ama tarihsel veriler için de yeterince uzak bir tarihti.

Orijinal uygulama, geçen saniye sayısını saklamak için 32 bit işaretli tamsayı kullanıyordu; bu, o zaman için Unix sistemlerinin beklenen ömrü için yeterliydi. Ancak, bu karar, Unix sistemlerinde 32 bit işaretli tamsayılar olarak saklanan standart Unix zaman damgalarının 19 Ocak 2038'de taşma yapacağı Yıl 2038 Sorunu'na yol açtı.

Hesaplama ihtiyaçları geliştikçe, daha yüksek hassasiyetli zaman damgalarına ihtiyaç duyulmaya başlandı:

• Milisaniye hassasiyeti (13 haneli), etkileşimli bilgisayarların yükselişi ve kullanıcı arayüzü yanıtını ölçme gereksinimi ile yaygın hale geldi.

• Mikrosaniye hassasiyeti (16 haneli), yüksek performanslı bilgisayar uygulamaları ve son derece hassas zamanlama gerektiren sistemlerle ortaya çıktı.

Unix ve Unix benzeri işletim sistemleri popülarite kazandıkça, Unix zaman damgası, bilgisayarda zaman temsilinin bir de facto standardı haline geldi. Birçok programlama dili, veritabanı ve uygulama, Unix ortamının ötesine geçerek bu standardı benimsedi.

Modern sistemler giderek 64 bit tamsayılar kullanarak zaman damgalarını saklamaktadır; bu, temsil edilebilir aralığı yaklaşık 292 milyar yıl ileri ve geri uzatarak Yıl 2038 sorununu etkili bir şekilde çözmektedir. Ancak, eski sistemler ve uygulamalar hala savunmasız olabilir.

Unix zaman damgasının basitliği ve faydası, daha sofistike zaman temsil formatlarının geliştirilmesine rağmen, onun devam eden geçerliliğini sağlamıştır. Dijital altyapımızın çoğunu destekleyen temel bir kavram olmaya devam etmektedir.

Kod Örnekleri

İşte çeşitli programlama dillerinde farklı hassasiyetlerdeki Unix zaman damgalarını insan tarafından okunabilir tarihlere dönüştürme örnekleri:

1// JavaScript zaman damgası dönüşümü otomatik format algılama ile
2function convertTimestamp(timestamp, use12Hour = false) {
3  // Gerekirse sayıya dönüştür
4  const numericTimestamp = Number(timestamp);
5  
6  // Hanelere göre zaman damgası formatını algıla
7  let date;
8  if (timestamp.length === 16) {
9    // Mikrosaniye hassasiyeti (saniyeyi almak için 1.000.000'a böl)
10    date = new Date(numericTimestamp / 1000);
11    console.log("Algılandı: Mikrosaniye hassasiyeti zaman damgası");
12  } else if (timestamp.length === 13) {
13    // Milisaniye hassasiyeti
14    date = new Date(numericTimestamp);
15    console.log("Algılandı: Milisaniye hassasiyeti zaman damgası");
16  } else if (timestamp.length === 10) {
17    // Standart Unix zaman damgası (saniye)
18    date = new Date(numericTimestamp * 1000);
19    console.log("Algılandı: Standart Unix zaman damgası (saniye)");
20  } else {
21    throw new Error("Geçersiz zaman damgası formatı. 10, 13 veya 16 haneli bekleniyor.");
22  }
23  
24  // Format seçenekleri
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  // Yerel biçimlendirme kullanarak dizeye dönüştür
37  return date.toLocaleString(undefined, options);
38}
39
40// Örnek kullanım
41try {
42  // Standart Unix zaman damgası (10 haneli)
43  console.log(convertTimestamp("1609459200", false)); 
44  
45  // Milisaniye hassasiyeti (13 haneli)
46  console.log(convertTimestamp("1609459200000", false)); 
47  
48  // Mikrosaniye hassasiyeti (16 haneli)
49  console.log(convertTimestamp("1609459200000000", true)); 
50} catch (error) {
51  console.error(error.message);
52}
53

1# Python zaman damgası dönüşümü otomatik format algılama ile
2import datetime
3
4def convert_timestamp(timestamp, use_12hour=False):
5    # Tam sayıya dönüştür
6    timestamp = str(timestamp).strip()
7    numeric_timestamp = int(timestamp)
8    
9    # Hanelere göre zaman damgası formatını algıla
10    if len(timestamp) == 16:
11        # Mikrosaniye hassasiyeti (saniyeyi almak için 1.000.000'a böl)
12        date = datetime.datetime.fromtimestamp(numeric_timestamp / 1000000)
13        print("Algılandı: Mikrosaniye hassasiyeti zaman damgası")
14    elif len(timestamp) == 13:
15        # Milisaniye hassasiyeti (saniyeyi almak için 1.000'e böl)
16        date = datetime.datetime.fromtimestamp(numeric_timestamp / 1000)
17        print("Algılandı: Milisaniye hassasiyeti zaman damgası")
18    elif len(timestamp) == 10:
19        # Standart Unix zaman damgası (saniye)
20        date = datetime.datetime.fromtimestamp(numeric_timestamp)
21        print("Algılandı: Standart Unix zaman damgası (saniye)")
22    else:
23        raise ValueError("Geçersiz zaman damgası formatı. 10, 13 veya 16 haneli bekleniyor.")
24    
25    # Tarih dizesini biçimlendir
26    if use_12hour:
27        format_string = "%A, %B %d, %Y %I:%M:%S %p"  # 12 saat formatı AM/PM ile
28    else:
29        format_string = "%A, %B %d, %Y %H:%M:%S"     # 24 saat formatı
30    
31    return date.strftime(format_string)
32
33# Örnek kullanım
34try:
35    # Standart Unix zaman damgası (10 haneli)
36    print(convert_timestamp("1609459200", False))
37    
38    # Milisaniye hassasiyeti (13 haneli)
39    print(convert_timestamp("1609459200000", False))
40    
41    # Mikrosaniye hassasiyeti (16 haneli)
42    print(convert_timestamp("1609459200000000", True))
43except ValueError as e:
44    print(e)
45

1<?php
2// PHP zaman damgası dönüşümü otomatik format algılama ile
3function convertTimestamp($timestamp, $use12Hour = false) {
4    // Girdi için bir dize sağlamak için trim yap
5    $timestamp = trim((string)$timestamp);
6    
7    // Hanelere göre zaman damgası formatını algıla
8    if (strlen($timestamp) === 16) {
9        // Mikrosaniye hassasiyeti (saniyeyi almak için 1.000.000'a böl)
10        $seconds = $numericTimestamp / 1000000;
11        echo "Algılandı: Mikrosaniye hassasiyeti zaman damgası\n";
12    } elseif (strlen($timestamp) === 13) {
13        // Milisaniye hassasiyeti (saniyeyi almak için 1.000'a böl)
14        $seconds = $numericTimestamp / 1000;
15        echo "Algılandı: Milisaniye hassasiyeti zaman damgası\n";
16    } elseif (strlen($timestamp) === 10) {
17        // Standart Unix zaman damgası (saniye)
18        $seconds = $numericTimestamp;
19        echo "Algılandı: Standart Unix zaman damgası (saniye)\n";
20    } else {
21        throw new Exception("Geçersiz zaman damgası formatı. 10, 13 veya 16 haneli bekleniyor.");
22    }
23    
24    // Format dizesi
25    $formatString = $use12Hour 
26        ? 'l, F j, Y g:i:s A'  // 12 saat formatı AM/PM ile
27        : 'l, F j, Y H:i:s';   // 24 saat formatı
28    
29    // Tarihi dönüştür ve biçimlendir
30    return date($formatString, $seconds);
31}
32
33// Örnek kullanım
34try {
35    // Standart Unix zaman damgası (10 haneli)
36    echo convertTimestamp("1609459200", false) . "\n";
37    
38    // Milisaniye hassasiyeti (13 haneli)
39    echo convertTimestamp("1609459200000", false) . "\n";
40    
41    // Mikrosaniye hassasiyeti (16 haneli)
42    echo convertTimestamp("1609459200000000", true) . "\n";
43} catch (Exception $e) {
44    echo $e->getMessage() . "\n";
45}
46?>
47

1// Java zaman damgası dönüşümü otomatik format algılama ile
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        // Girdiyi trimle
10        timestamp = timestamp.trim();
11        
12        // Hanelere göre zaman damgası formatını algıla
13        LocalDateTime dateTime;
14        if (timestamp.length() == 16) {
15            // Mikrosaniye hassasiyeti (saniyeyi almak için 1.000.000'a böl)
16            long microseconds = Long.parseLong(timestamp);
17            Instant instant = Instant.ofEpochSecond(0, microseconds * 1000); // Nanosecond'e dönüştür
18            dateTime = LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
19            System.out.println("Algılandı: Mikrosaniye hassasiyeti zaman damgası");
20        } else if (timestamp.length() == 13) {
21            // Milisaniye hassasiyeti
22            long milliseconds = Long.parseLong(timestamp);
23            Instant instant = Instant.ofEpochMilli(milliseconds);
24            dateTime = LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
25            System.out.println("Algılandı: Milisaniye hassasiyeti zaman damgası");
26        } else if (timestamp.length() == 10) {
27            // Standart Unix zaman damgası (saniye)
28            long seconds = Long.parseLong(timestamp);
29            Instant instant = Instant.ofEpochSecond(seconds);
30            dateTime = LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
31            System.out.println("Algılandı: Standart Unix zaman damgası (saniye)");
32        } else {
33            throw new IllegalArgumentException("Geçersiz zaman damgası formatı. 10, 13 veya 16 haneli bekleniyor.");
34        }
35        
36        // İstenilen formata göre biçimlendirici oluştur
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        // Tarihi biçimlendir
42        return dateTime.format(formatter);
43    }
44    
45    public static void main(String[] args) {
46        try {
47            // Standart Unix zaman damgası (10 haneli)
48            System.out.println(convertTimestamp("1609459200", false));
49            
50            // Milisaniye hassasiyeti (13 haneli)
51            System.out.println(convertTimestamp("1609459200000", false));
52            
53            // Mikrosaniye hassasiyeti (16 haneli)
54            System.out.println(convertTimestamp("1609459200000000", true));
55        } catch (IllegalArgumentException e) {
56            System.err.println(e.getMessage());
57        }
58    }
59}
60

1// C# zaman damgası dönüşümü otomatik format algılama ile
2using System;
3
4class TimestampConverter
5{
6    public static string ConvertTimestamp(string timestamp, bool use12Hour)
7    {
8        // Girdiyi trimle
9        timestamp = timestamp.Trim();
10        
11        // Hanelere göre zaman damgası formatını algıla
12        DateTime dateTime;
13        if (timestamp.Length == 16)
14        {
15            // Mikrosaniye hassasiyeti (saniyeyi almak için 1.000.000'a böl)
16            if (!double.TryParse(timestamp, out double microseconds))
17                throw new ArgumentException("Geçersiz zaman damgası formatı");
18                
19            // Mikrosaniyeleri DateTime'a dönüştür
20            dateTime = DateTimeOffset.FromUnixTimeSeconds(0).DateTime.AddSeconds(microseconds / 1000000);
21            Console.WriteLine("Algılandı: Mikrosaniye hassasiyeti zaman damgası");
22        }
23        else if (timestamp.Length == 13)
24        {
25            // Milisaniye hassasiyeti
26            if (!long.TryParse(timestamp, out long milliseconds))
27                throw new ArgumentException("Geçersiz zaman damgası formatı");
28                
29            dateTime = DateTimeOffset.FromUnixTimeMilliseconds(milliseconds).DateTime;
30            Console.WriteLine("Algılandı: Milisaniye hassasiyeti zaman damgası");
31        }
32        else if (timestamp.Length == 10)
33        {
34            // Standart Unix zaman damgası (saniye)
35            if (!long.TryParse(timestamp, out long seconds))
36                throw new ArgumentException("Geçersiz zaman damgası formatı");
37                
38            dateTime = DateTimeOffset.FromUnixTimeSeconds(seconds).DateTime;
39            Console.WriteLine("Algılandı: Standart Unix zaman damgası (saniye)");
40        }
41        else
42        {
43            throw new ArgumentException("Geçersiz zaman damgası formatı. 10, 13 veya 16 haneli bekleniyor.");
44        }
45        
46        // 12 saatlik veya 24 saatlik tercihe göre biçim dizesi
47        string formatString = use12Hour 
48            ? "dddd, MMMM d, yyyy h:mm:ss tt"  // 12 saat formatı AM/PM ile
49            : "dddd, MMMM d, yyyy HH:mm:ss";   // 24 saat formatı
50        
51        // Biçimlendirilmiş tarih dizesini döndür
52        return dateTime.ToString(formatString);
53    }
54    
55    static void Main()
56    {
57        try
58        {
59            // Standart Unix zaman damgası (10 haneli)
60            Console.WriteLine(ConvertTimestamp("1609459200", false));
61            
62            // Milisaniye hassasiyeti (13 haneli)
63            Console.WriteLine(ConvertTimestamp("1609459200000", false));
64            
65            // Mikrosaniye hassasiyeti (16 haneli)
66            Console.WriteLine(ConvertTimestamp("1609459200000000", true));
67        }
68        catch (ArgumentException e)
69        {
70            Console.WriteLine(e.Message);
71        }
72    }
73}
74

Kenar Durumlarını Yönetme

Farklı hassasiyetlerdeki Unix zaman damgaları ile çalışırken, kenar durumlarını doğru bir şekilde yönetmek önemlidir. İşte kapsamlı bir kenar durumu yönetimi örneği:

1// JavaScript kapsamlı kenar durumu yönetimi çoklu zaman damgası formatları için
2function safeConvertTimestamp(timestamp, use12Hour = false) {
3  // Girdi doğrulama
4  if (timestamp === undefined || timestamp === null || timestamp === '') {
5    return "Hata: Boş veya tanımsız zaman damgası";
6  }
7  
8  // Hanelere göre zaman damgası formatını algıla
9  const timestampStr = String(timestamp).trim();
10  
11  // Zaman damgasının yalnızca rakam içerip içermediğini kontrol et
12  if (!/^\d+$/.test(timestampStr)) {
13    return "Hata: Zaman damgası yalnızca rakam içermelidir";
14  }
15  
16  // Hanelere göre formatı algıla
17  let date;
18  try {
19    if (timestampStr.length === 16) {
20      // Mikrosaniye hassasiyeti
21      const microseconds = Number(timestampStr);
22      date = new Date(microseconds / 1000); // Milisaniyeye dönüştür
23      console.log("Mikrosaniye zaman damgası işleniyor (16 haneli)");
24      
25      // Geçersiz tarih kontrolü
26      if (isNaN(date.getTime())) {
27        return "Hata: Geçersiz mikrosaniye zaman damgası";
28      }
29    } else if (timestampStr.length === 13) {
30      // Milisaniye hassasiyeti
31      const milliseconds = Number(timestampStr);
32      date = new Date(milliseconds);
33      console.log("Milisaniye zaman damgası işleniyor (13 haneli)");
34      
35      // Geçersiz tarih kontrolü
36      if (isNaN(date.getTime())) {
37        return "Hata: Geçersiz milisaniye zaman damgası";
38      }
39    } else if (timestampStr.length === 10) {
40      // Standart Unix zaman damgası (saniye)
41      const seconds = Number(timestampStr);
42      date = new Date(seconds * 1000);
43      console.log("Standart zaman damgası işleniyor (10 haneli)");
44      
45      // Geçersiz tarih kontrolü
46      if (isNaN(date.getTime())) {
47        return "Hata: Geçersiz standart zaman damgası";
48      }
49      
50      // Y2K38 sorunu için kontrol (32 bit sistemler için)
51      const maxInt32 = 2147483647; // 32 bit işaretli tamsayı için maksimum değer
52      if (seconds > maxInt32) {
53        console.warn("Uyarı: Zaman damgası 32 bit tamsayı limitini aşıyor (Y2K38 sorunu)");
54      }
55    } else {
56      return "Hata: Geçersiz zaman damgası uzunluğu. 10, 13 veya 16 haneli bekleniyor.";
57    }
58    
59    // Tarihi biçimlendir
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 "Zaman damgasını dönüştürürken hata: " + error.message;
74  }
75}
76
77// Çeşitli kenar durumları ile test et
78console.log(safeConvertTimestamp("1609459200"));      // Standart (10 haneli)
79console.log(safeConvertTimestamp("1609459200000"));   // Milisaniye (13 haneli)
80console.log(safeConvertTimestamp("1609459200000000")); // Mikrosaniye (16 haneli)
81console.log(safeConvertTimestamp("abc123"));          // Sayısal olmayan
82console.log(safeConvertTimestamp("12345"));           // Geçersiz uzunluk
83console.log(safeConvertTimestamp("9999999999999999")); // Çok büyük mikrosaniye zaman damgası
84console.log(safeConvertTimestamp(""));                // Boş dize
85

Sıkça Sorulan Sorular

Unix zaman damgası nedir?

Unix zaman damgası, 1 Ocak 1970'ten (orta gece UTC/GMT) itibaren geçen saniye sayısıdır; artık saniyeleri saymaz. Belirli bir zaman anını temsil etmek için kompakt, dil bağımsız bir yol sağlar.

Otomatik zaman damgası format algılama nasıl çalışır?

Dönüştürücü, zaman damgası formatını hanelerine göre otomatik olarak algılar:

• 10 haneli: Standart Unix zaman damgası (epoch'tan itibaren saniyeler)
• 13 haneli: Milisaniye hassasiyeti zaman damgası
• 16 haneli: Mikrosaniye hassasiyeti zaman damgası

Milisaniye veya mikrosaniye hassasiyetine neden ihtiyaç duyarım?

Milisaniye hassasiyeti (13 haneli), performans izleme, kullanıcı etkileşimi takibi ve belirli finansal uygulamalar gibi daha doğru zamanlama gerektiren uygulamalar için kullanışlıdır. Mikrosaniye hassasiyeti (16 haneli), yüksek performanslı bilgisayarlar, bilimsel uygulamalar ve yüksek frekanslı ticaret sistemleri için kritik öneme sahiptir.

1970'ten önceki tarihleri Unix zaman damgaları ile dönüştürebilir miyim?

Evet, 1 Ocak 1970'ten önceki tarihler negatif zaman damgaları ile temsil edilir. Ancak, bazı sistemler negatif zaman damgalarını doğru bir şekilde işleyemeyebilir, bu nedenle tarihi verilerle çalışıyorsanız bu işlevselliği test etmek önemlidir.

Yıl 2038 sorunu nedir?

Yıl 2038 sorunu, birçok sistemin Unix zaman damgalarını 32 bit işaretli tamsayılar olarak saklaması nedeniyle ortaya çıkar; bu, 19 Ocak 2038'de taşma yapacaktır (03:14:07 UTC). Bu tarihten sonra, 32 bit sistemler doğru zamanları temsil edemeyecektir. Modern sistemler giderek 64 bit tamsayılar kullanarak bu sorunu önlemektedir.

Unix zaman damgaları ile zaman dilimi dönüşümlerini nasıl yönetebilirim?

Unix zaman damgaları her zaman UTC (Eşgüdümlü Evrensel Zaman) ile temsil edilir. Yerel zamana dönüştürmek, zaman dilimi ayarlaması gerektirir. Çoğu programlama dili, zaman dilimi dönüşümlerini yönetmek için yerleşik işlevler sağlar.

Unix zamanı ile ISO 8601 arasındaki fark nedir?

Unix zamanı sayısal bir temsildir (epoch'tan itibaren geçen saniyeler), ISO 8601 ise bir dize formatıdır (örneğin, "2021-01-01T00:00:00Z"). Unix zamanı, hesaplamalar için daha kompakt ve daha kolaydır, oysa ISO 8601 daha okunabilir ve kendine açıklayıcıdır.

Unix zaman damgaları ne kadar doğrudur?

Standart Unix zaman damgaları saniye düzeyinde hassasiyete sahiptir. Daha fazla hassasiyet gerektiren uygulamalar için milisaniye zaman damgaları (13 haneli) 1/1000 saniye hassasiyeti sağlar ve mikrosaniye zaman damgaları (16 haneli) 1/1.000.000 saniye hassasiyeti sunar.

Unix zaman damgaları artık saniyeleri hesaba katıyor mu?

Hayır, Unix zamanı, UTC'ye zaman zaman eklenen artık saniyeleri hesaba katmaz. Bu, Unix zamanının astronomik zamanla tam olarak senkronize olmadığı anlamına gelir.

Gelecek olayları planlamak için Unix zaman damgalarını kullanabilir miyim?

Evet, Unix zaman damgaları planlama için yaygın olarak kullanılır. Ancak, çok uzak gelecekteki tarihler için Yıl 2038 sorunu gibi potansiyel sınırlamaların farkında olmalısınız.

Referanslar

1. "Unix Zamanı." Vikipedi, Wikimedia Vakfı, https://en.wikipedia.org/wiki/Unix_time

2. "Yıl 2038 Sorunu." Vikipedi, Wikimedia Vakfı, https://en.wikipedia.org/wiki/Year_2038_problem

3. Olson, Arthur David. "Takvimsel Zamanın Karmaşıklıkları." The Open Group, https://www.usenix.org/legacy/events/usenix01/full_papers/olson/olson.pdf

4. "ISO 8601." Vikipedi, Wikimedia Vakfı, https://en.wikipedia.org/wiki/ISO_8601

5. "RFC 3339: İnternet Üzerinde Tarih ve Zaman: Zaman Damgaları." İnternet Mühendisliği Görev Gücü (IETF), https://tools.ietf.org/html/rfc3339

6. Kernighan, Brian W., ve Dennis M. Ritchie. "C Programlama Dili." Prentice Hall, 1988.

7. "Yüksek Performanslı Bilgisayarlarda Hassas Zamanlama." ACM Computing Surveys, https://dl.acm.org/doi/10.1145/3232678

8. "Finansal Sistemlerde Zaman Temsili." Finansal Teknoloji Dergisi, https://www.fintech-journal.com/time-representation

Şimdi zaman damgası dönüştürücümüzü deneyin ve herhangi bir hassasiyetteki Unix zaman damgalarını insan tarafından okunabilir tarihlere kolayca dönüştürün. İster standart Unix zaman damgaları, ister milisaniye hassasiyeti, ister mikrosaniye hassasiyeti olsun, aracımız formatı otomatik olarak algılar ve doğru dönüşümler sağlar.