Skip to content

Unix Zaman Damgası ve Epoch Dönüştürücü — Çoklu Hassasiyet

Unix zaman damgasını anında tarihe dönüştürün. Saniye, milisaniye ve mikrosaniyeyi otomatik algılar. Canlı saat, çift yönlü. Ücretsiz ve gizliliğe saygılı.

Takip Yok Tarayıcıda Çalışır Ücretsiz
Tüm işlemler tarayıcınızda gerçekleşir. Hiçbir sunucuya veri gönderilmez.

Güncel Unix Zaman Damgası

0

Hızlı Başvuru

Kod Örnekleri

POSIX uyumluluğu ve hassasiyet doğruluğu için incelendi — Go Tools Mühendislik Ekibi · Mar 22, 2026

Unix Zaman Damgası (Epoch Time) Nedir?

Unix zaman damgası (epoch zamanı veya POSIX zamanı olarak da bilinir), 1 Ocak 1970 00:00:00 UTC'den bu yana geçen saniye sayısıdır ve hemen hemen tüm bilişim sistemleri için evrensel zaman referansı görevi görür. Linux çekirdeklerinden ve SQL veritabanlarından, JavaScript motorlarına ve mobil işletim sistemlerine kadar günümüzün neredeyse her platformu zamanı Unix zaman damgası olarak saklar ve değiş tokuş eder.

IEEE Std 1003.1 (POSIX) standardının resmi tanımıyla: "Unix epoch (1 Ocak 1970 00:00:00 UTC), POSIX zamanı için sıfır noktası olarak hizmet eder" — bu uzlaşı o kadar yaygın benimsenmiştir ki bugün makine tarafından okunabilir zaman damgaları için dünya çapındaki fiili standarttır. Unix zaman damgaları; HTTP başlıkları, JWT token'ları ve neredeyse tüm REST API'ler dahil olmak üzere sunucu tarafı sistemlerin, veritabanlarının ve ağ protokollerinin büyük çoğunluğu tarafından kullanılır.

Unix epoch'un kendisi — 1 Ocak 1970 — rastgele seçilmemiştir. Unix, 1960'ların sonunda Bell Labs'ta geliştirilmişti ve 1970, ilgili tüm tarihleri yönetilebilir tamsayı boyutlarıyla temsil edebilecek kadar yakın geçmişte yer alan, kullanışlı ve yuvarlak bir başlangıç noktasıydı. Zamanın herhangi bir anı, bu sabit noktadan itibaren işaretli 64 bitlik tamsayı saniye sayısı olarak ifade edilebilir. Epoch'tan önceki tarihler negatif sayılarla gösterilir: 31 Aralık 1969 gece yarısı UTC, -86400 değerine (epoch'tan bir gün, yani 86.400 saniye önceye) karşılık gelir.

Modern sistemler genellikle tam saniyeden daha yüksek zaman çözünürlüğüne ihtiyaç duyar. Bunu karşılamak için zaman damgaları yaygın olarak milisaniye (saniyenin binde biri; JavaScript'in `Date.now()` veya Java'nın `System.currentTimeMillis()` çağrılarının döndürdüğü değer) ya da mikrosaniye (saniyenin milyonda biri; PostgreSQL gibi veritabanlarında ve yüksek frekanslı işlem sistemlerinde kullanılır) cinsinden ifade edilir. Hassasiyeti hane sayısından anlayabilirsiniz: 10 hane saniye, 13 hane milisaniye, 16 hane ise mikrosaniyeyi gösterir. Bu dönüştürücü, girdinizin hassasiyetini otomatik olarak algılar.

Unix zaman damgaları dağıtık sistemlerin omurgasıdır; çünkü saat diliminden bağımsızdır, (normal koşullarda) monoton biçimde artar ve tamsayı olarak kolayca sıralanabilir. Zamanı zaman damgası olarak saklayıp yalnızca görüntüleme aşamasında insan tarafından okunabilir biçimlere dönüştürmek, saat dilimi kaynaklı tüm hata kategorilerini ortadan kaldıran bir en iyi uygulamadır. Karşılığında okunabilirlikten ödün verilir — 1741965432 gibi ham bir zaman damgası dönüştürücü olmadan anlamsız görünür; bu araç da tam olarak bu boşluğu doldurur.

Tüm dönüşümler tarayıcınızda JavaScript Date API kullanılarak gerçekleştirilir — hiçbir zaman damgası, tarih veya başka bir veri sunucuya gönderilmez. Bu araç, yukarıdaki canlı saatte gösterilen güncel epoch zamanı dahil herhangi bir Unix zaman damgasını anında ve gizliliğinizi koruyarak insan tarafından okunabilir bir tarihe dönüştürür.

Zaman damgaları, başka geliştirici araçlarıyla yakından ilişkilidir. UUID v1 ve v7, zaman damgalarını doğrudan kimliklerinin içine gömer ve zaman damgaları içeren API yanıtlarını okumak için en iyi yol genellikle bir JSON biçimlendiriciden geçer. Hassasiyet, saat dilimi yönetimi ve DST tuzakları ile JavaScript, Python ve Go kod örnekleri içeren ayrıntılı bir rehber için Unix zaman damgası rehberimizi okuyun.

// Get the current Unix timestamp in JavaScript
const timestampSeconds = Math.floor(Date.now() / 1000);
console.log(timestampSeconds); // → 1741965432

// Milliseconds (native JavaScript)
const timestampMs = Date.now();
console.log(timestampMs); // → 1741965432000

// Convert timestamp back to a Date object
const date = new Date(timestampSeconds * 1000);
console.log(date.toISOString()); // → '2025-03-14T15:37:12.000Z'

// Python equivalent
// import time
// timestamp = int(time.time())  # → 1741965432

Temel Özellikler

Otomatik Hassasiyet Algılama

Zaman damgasının saniye (10 hane), milisaniye (13 hane) veya mikrosaniye (16 hane) olduğunu otomatik olarak algılar — manuel mod değişikliği gerektirmez.

Çift Yönlü Dönüşüm

Zaman damgalarını insan tarafından okunabilir tarihlere çevirin ya da bir tarih ve saat seçerek karşılık gelen Unix zaman damgasını her üç hassasiyet biçiminde anında üretin.

Canlı Epoch Saati

Güncel Unix zaman damgasını gerçek zamanlı işlerken görün; böylece dönüşümleriniz ve hesaplamalarınız için her zaman doğru bir referans noktanız olsun.

Çok Biçimli Çıktı

Her dönüşüm UTC saatini, yerel saat diliminizi, ISO 8601 biçimini ve insan dostu göreli zamanı (örn. "3 gün önce") aynı anda üretir.

%100 Tarayıcı Tarafı İşleme

Tüm dönüşümler tarayıcınızda JavaScript Date API kullanılarak gerçekleştirilir. Hiçbir zaman damgası, tarih veya kişisel veri sunucuya iletilmez.

Unix Zaman Damgası ve Diğer Tarih Biçimleri

ISO 8601

2025-03-14T15:37:12Z

Hem insan tarafından okunabilir hem de sözlük sırasına göre sıralanabilir. Veri alışverişi ve API'ler için standarttır. İnsan okunabilirliği önemli olduğunda Unix zaman damgalarına tercih edilir.

RFC 2822

Fri, 14 Mar 2025 15:37:12 +0000

İnsan tarafından okunabilir, ancak sıralanabilir değildir. Esas olarak e-posta başlıklarında (Date alanı) kullanılır. ISO 8601 ve Unix zaman damgalarına göre daha az kompakttır.

İnsan Okunur Tarih

14 Mart 2025 15:37

Son kullanıcılar için en okunaklı biçim, ancak sıralanabilir veya programatik kullanıma uygun değildir. En iyisi yalnızca arayüz görüntüleme katmanlarında kullanmaktır.

Dönüşüm Örnekleri

Standart Unix Zaman Damgası (saniye)

1741965432
2025-03-14T15:37:12Z

Saniye cinsinden 10 haneli bir zaman damgası — Unix/Linux sistemleri, Unix API'leri, JWT token'ları ve sunucu logları tarafından kullanılan en yaygın biçimdir. Bu özel değer, 2025 Pi Günü'ne, 15:37:12 UTC saatine karşılık gelir.

Y2K Zaman Damgası — 1 Ocak 2000

946684800
2000-01-01T00:00:00Z

Y2K anına karşılık gelen Unix zaman damgası: Unix epoch'tan tam olarak 946.684.800 saniye sonra. Yararlı bir kalibrasyon değeridir — dönüştürücünüz bu girdi için 1 Ocak 2000 sonucunu veriyorsa doğru çalışıyor demektir.

Negatif Zaman Damgası (Epoch'tan Önce)

-86400
1969-12-31T00:00:00Z

Negatif Unix zaman damgaları, 1 Ocak 1970'ten önceki tarihleri temsil eder. -86400 değeri, epoch'tan tam bir gün (86.400 saniye) öncesine; yani 31 Aralık 1969 gece yarısı UTC saatine karşılık gelir. Tüm sistemler negatif zaman damgalarını desteklemez, ancak bu dönüştürücü onları doğru biçimde işler.

Milisaniye Zaman Damgası (13 hane)

1741965432000
2025-03-14T15:37:12.000Z

Milisaniye cinsinden 13 haneli bir zaman damgası — JavaScript'in Date.now() fonksiyonunun, Java'nın System.currentTimeMillis() çağrısının ve modern REST API'lerin çoğunun yerel biçimi. İlk örneğin 1000 ile çarpılmış halidir. Otomatik algılayıcı 13 hanelik uzunluğu tanır ve değeri doğru şekilde milisaniye olarak çözümler.

Unix Zaman Damgası Tarihe Nasıl Dönüştürülür

  1. 1

    Dönüşüm Yönünü Seçin

    Bir Unix zaman damgasını insan tarafından okunabilir bir tarihe çözmek için "Zaman Damgası → Tarih" sekmesini, bir takvim tarihi ve saatini Unix zaman damgasına dönüştürmek için "Tarih → Zaman Damgası" sekmesini seçin.

  2. 2

    Değerinizi Girin

    Giriş alanına bir Unix zaman damgası (örn. 1741965432 veya 1741965432000) yapıştırın ya da yazın. Araç, değerin saniye, milisaniye ya da mikrosaniye cinsinden olduğunu otomatik tanır. Tarih → Zaman Damgası için tarih seçici ile yıl, ay, gün, saat, dakika ve saniyeyi belirleyin.

  3. 3

    Dönüştürülmüş Sonucu Kopyalayın

    Sonucu UTC, yerel saat, ISO 8601 ve göreli zaman olarak anında görün. Herhangi bir biçimi doğrudan panoya kopyalamak için yanındaki Kopyala düğmesine tıklayın.

Yaygın Kullanım Senaryoları

API Geliştirme ve Hata Ayıklama
API yanıtlarındaki, JWT token yüklerindeki (iat, exp, nbf claim'leri), webhook olay verilerindeki ve log girdilerindeki anlamı kapalı zaman damgalarını çözün. Bir kimlik doğrulama token'ının süresinin dolup dolmadığını veya bir olayın tam olarak ne zaman gerçekleştiğini anında doğrulayın.
Veritabanı Zaman Damgası Saklama ve Sorguları
Veritabanı sorguları yazarken, saklanan kayıtları incelerken ya da WHERE yan tümcelerinizdeki tarih aralığı filtrelerinin doğru tanımlandığını doğrularken Unix zaman damgaları ile insan tarafından okunabilir tarihler arasında dönüşüm yapın.
Log Dosyası Çözümleme ve İlişkilendirme
Pek çok sistem ve uygulama logu olayları Unix zaman damgası olarak kaydeder. Şüpheli log girdilerini birden fazla servis arasında olayları ilişkilendirmek, saldırı pencerelerini belirlemek veya bir hatanın gerçekleştiği tam anı saptamak için insan tarafından okunabilir saatlere dönüştürün.
JWT Token Süre Dolma Doğrulaması
JSON Web Token'lar yüklerinde iat (verilme zamanı), exp (sona erme zamanı) ve nbf (önce geçerli değil) bilgilerini Unix zaman damgası olarak kodlar. Token geçerlilik pencerelerini, epoch matematiğini elle yapmadan doğrulamak için bu değerleri doğrudan yapıştırın.
Cron Görevleri Planlama
Önerilen çalıştırma zamanlarını zaman damgalarına ve geri çevirerek cron görev programlarının, zamanlanmış görevlerin ve zaman tabanlı tetikleyicilerin amaçlanan yürütme pencereleriyle uyumlu olduğunu doğrulayın.
Saat Dilimleri Arası Tarih Koordinasyonu
Unix zaman damgaları doğası gereği saat diliminden bağımsızdır. Farklı saat dilimlerindeki ekipler arasında tarih ve son tarihleri koordine ederken ortak bir referans noktası belirlemek ve herhangi bir yerel saatin UTC karşılığını doğrulamak için bu dönüştürücüyü kullanın.

Teknik Referans

Unix Zaman Damgası Tanımı
Unix zaman damgası, Unix epoch'tan (1 Ocak 1970 00:00:00 UTC, Eşgüdümlü Evrensel Zaman) bu yana geçen saniyelerin tam sayı sayımıdır. Değer, gözlemcinin yerel saat diliminden bağımsız olarak aynıdır; bu da onu zamanın saklanması ve karşılaştırılması için ideal, saat diliminden bağımsız bir gösterim haline getirir.
Maksimum 32 Bit İşaretli Tamsayı Değeri
İşaretli 32 bitlik bir tamsayının maksimum değeri 2.147.483.647'dir. Unix zaman damgası olarak bu, 19 Ocak 2038 03:14:07 UTC'ye karşılık gelir. Zaman damgalarını 32 bitlik işaretli tamsayılarda saklayan sistemler bu anda taşma yaşar — bu, 2038 Yılı sorunu olarak bilinir. 64 bitlik sistemler ise milyarlarca yıl geleceğe ait tarihleri rahatça temsil edebilir.
JavaScript Milisaniye Kullanır
JavaScript'te Date.now() ve new Date().getTime() çağrıları epoch'tan bu yana geçen saniyeleri değil, milisaniyeleri döndürür. Bu da 13 haneli sayılar üretir. Standart, saniye cinsinden Unix zaman damgasına dönüştürmek için 1000'e bölüp tabana yuvarlayın: Math.floor(Date.now() / 1000). Pek çok API ve araç saniye bekler; bu nedenle bu dönüşüm adımı kritik önem taşır.
Negatif Zaman Damgaları Epoch Öncesi Tarihleri Temsil Eder
Unix zaman damgaları, 1 Ocak 1970 öncesindeki tarihleri temsil etmek için negatif olabilir. Örneğin -86400 değeri, 31 Aralık 1969 00:00:00 UTC'ye karşılık gelir. İşaretli 64 bit zaman damgasının aralığı epoch'tan kabaca 292 milyar yıl öncesinden 292 milyar yıl sonrasına kadar uzanır; bu, herhangi bir pratik uygulama için fazlasıyla yeterlidir.
Unix Zamanı Artık Saniyeleri Hesaba Katmaz
Unix zamanı, bir günün tam olarak 86.400 saniyeden (24 saat × 60 dakika × 60 saniye) oluştuğunu varsayar. Gerçekte ise Dünya'nın dönüşüyle UTC'yi senkronize tutmak için IERS tarafından zaman zaman artık saniyeler eklenir. Bu, Unix zamanının TAI (Uluslararası Atom Zamanı) ile mükemmel biçimde doğrusal olmadığı ve farkın zamanla büyüdüğü anlamına gelir. Çoğu uygulama için bu tutarsızlık önemsizdir, ancak yüksek hassasiyetli zaman tutma sistemlerinin bunu hesaba katması gerekir.

Zaman Damgası Yönetimi için En İyi Uygulamalar

Zaman Damgalarını Her Zaman UTC ile Saklayın
Zaman damgalarını UTC olarak (veya Unix zaman damgası olarak) saklayın ve yerel saate yalnızca görüntüleme katmanında dönüştürün. Veritabanınızda saat dilimlerini karıştırmak, özellikle yaz saati uygulaması geçişlerinde tekrar üretilmesi ve ayıklanması zor olan hataların yaygın bir kaynağıdır.
Modern API'ler için Milisaniye Hassasiyetini Kullanın
Modern API'lerin, JavaScript çalışma zamanlarının ve veritabanlarının çoğu, saniyeden (10 haneli zaman damgası) çok milisaniye (13 haneli zaman damgası) kullanır. Dış sistemlerle entegrasyonda beklenen hassasiyeti doğrulayın — saniye beklenen yerde milisaniyelik bir zaman damgası geçirmek, kabaca 11.000 yıl sonrasındaki tarihler üretir.
2038 Yılı Sorununa Dikkat Edin
Unix zaman damgalarını 32 bitlik işaretli tamsayılarda saklayan sistemler 19 Ocak 2038 03:14:07 UTC'de taşacaktır. Eski sistemleri 32 bitlik zaman damgası alanları açısından gözden geçirin ve 64 bit tamsayılara veya ISO 8601 dizelerine geçin. Modern dillerin ve veritabanlarının çoğu varsayılan olarak 64 bit zaman damgası kullanır; ancak gömülü sistemler, eski veritabanları ve dosya sistemleri hâlâ risk altında olabilir.
Güvenlik için İstemci Tarafı Saatlere Asla Güvenmeyin
İstemci cihaz saatleri kazara veya kötü niyetle herhangi bir değere ayarlanabilir. JWT süre dolma denetimleri, oturum zaman aşımları veya hız sınırlama gibi güvenlik açısından kritik mantık için istemcinin ilettiği zaman damgalarını asla kullanmayın. Zaman damgalarını her zaman güvenilir bir zaman kaynağı kullanarak sunucuda doğrulayın.
İnsan Tarafından Okunabilir Veri Alışverişi için ISO 8601 Kullanın
Hem makine tarafından çözümlenebilir hem de insan tarafından okunabilir bir zaman damgası biçimine ihtiyaç duyduğunuzda — örneğin log dosyalarında, yapılandırma dosyalarında veya bir geliştiricinin çıktıyı okuyabileceği API yanıtlarında — ISO 8601 (örn. 2025-03-14T15:37:12Z) en iyi seçenektir. Sözlük sırasına göre sıralanabilir, belirsizliği yoktur ve günümüzdeki neredeyse tüm ayrıştırıcılar tarafından desteklenir.

Sıkça Sorulan Sorular

Unix zamanı neden 1 Ocak 1970'ten başlar?
1 Ocak 1970 olan Unix epoch tarihi, Unix'in 1960'ların sonunda Bell Labs'taki geliştiricileri tarafından hem yakın geçmişte yer alan hem de hesaplama açısından elverişli, kullanışlı ve yuvarlak bir başlangıç noktası olarak seçildi. O dönemde zaman damgaları 32 bit tamsayılarda saklanıyordu; bu yüzden epoch'un yaygın tarihlerin makul büyüklükte bir sayıya sığacağı kadar günümüze yakın olması gerekiyordu. 1970, sistemin geliştirilmeye başlandığı dönemden hemen sonra gelen, temiz ve yuvarlak bir yıldı. 1 Ocak 1970'in özel olarak derin bir teknik anlamı yoktur — bu bir mühendislik pragmatizmiydi. Diğer sistemler farklı epoch'lar seçti: klasik Macintosh araç kutusu 1 Ocak 1904'ü, Windows NT 1 Ocak 1601'i, GPS zamanı 6 Ocak 1980'i kullanır. Her biri, kendisini seçen sistemin dönemini ve tasarım kısıtlarını yansıtır. Unix epoch'u kalıcı kılan şey, Unix'in bilişimde baskın işletim sistemi haline gelmesi ve sonunda her büyük programlama dilinin, veritabanının ve işletim sisteminin makine tarafından okunabilir zaman damgalarını temsil etmek için Unix zamanını evrensel standart olarak benimsemesidir. Bugün Unix epoch fiilen bilişimde evrensel bir sabittir; Linux çekirdeklerinden JavaScript motorlarına ve SQL veritabanlarına kadar her büyük platform tarafından tanınır. Bu seçimin iyi bilinen bir sonucu vardır: 1 Ocak 1970 öncesi tarihler negatif sayılarla temsil edilir ve bazı eski sistemler bunu işleyemez. Tarihsel tarihler ve astronomik hesaplamalar için bazen alternatif zaman damgası biçimleri tercih edilir. Ancak yazılım geliştirmenin büyük çoğunluğunda Unix epoch tüm ilgili tarihleri rahatça kapsar.
2038 Yılı sorunu nedir?
2038 Yılı sorunu (Y2K38 ya da Epochalypse olarak da bilinir), Unix zaman damgalarını işaretli 32 bit tamsayılar olarak saklayan sistemleri etkileyecek bir bilişim sorunudur. İşaretli bir 32 bit tamsayı -2.147.483.648 ile 2.147.483.647 arasındaki değerleri tutabilir. Unix zaman damgası olarak yorumlandığında, maksimum değer olan 2.147.483.647 değeri 19 Ocak 2038 03:14:07 UTC'ye karşılık gelir. Bir saniye sonra sayaç taşar ve temsil edilebilen en negatif değere geri sarılır; bu da 13 Aralık 1901'e karşılık gelir — böylece bu sistemler gelecek tarihleri çok geçmişte gibi yorumlar. Sonuçlar, zaman damgalarının nasıl kullanıldığına göre önemsizden felakete kadar değişebilir. Sistemler giriş doğrulaması sırasında geçerli gelecek tarihleri reddedebilir, zamana duyarlı kayıtları yanlış sıralayabilir, sertifikalar ve token'lar için süre dolma tarihlerini hatalı hesaplayabilir veya taşma değeriyle karşılaştığında tamamen çökebilir. Çözüm basittir: zaman damgası saklamak için 64 bit işaretli tamsayılara geçmek. 64 bitlik bir zaman damgası epoch'tan yaklaşık 292 milyar yıl öncesi ve sonrasındaki tarihleri temsil edebilir — pratik herhangi bir endişenin çok ötesinde. Modern işletim sistemlerinin, programlama dillerinin ve veritabanlarının çoğu zaten dahili olarak 64 bit zaman damgası kullanır. Risk; eski koddur, gömülü sistemlerdir, hâlâ üretimde olan 32 bit işletim sistemleridir, dosya sistemi meta verileridir (ör. FAT32'nin zaman damgası alanları) ve BIGINT yerine INT olarak tanımlanmış veritabanı sütunlarıdır. Geliştiriciler sistemlerini şimdiden gözden geçirmelidir. 32 bitten 64 bite geçişin 2038'den önce tamamlanması gerekir; pratikte ise uzun ömürlü kayıtlar barındıran sistemler (ipotekler, altyapı varlıkları, hukuki belgeler) etkilenen alanlara gelecek tarihler girildikçe sorunla çok daha erken karşılaşabilir.
Saniye, milisaniye ve mikrosaniye zaman damgaları arasındaki fark nedir?
Unix zaman damgaları, değerdeki hane sayısıyla ayırt edilen üç yaygın hassasiyette gelir: **Saniye (10 hane)**: Özgün ve en yaygın Unix zaman damgası biçimi. `1741965432`, zamanda belirli bir saniyeyi temsil eder. Kullananlar: Unix/Linux sistem çağrıları (`time()`), çoğu Unix yardımcı programı, JWT token'ları (`iat`, `exp` claim'leri), HTTP başlıkları (`Last-Modified`) ve birçok REST API. Mevcut zaman damgası yaklaşık 10 hane uzunluğundadır. **Milisaniye (13 hane)**: Saniyenin binde biri hassasiyeti. `1741965432000` yukarıdakiyle aynı andır, 1.000 ile çarpılmıştır. Kullananlar: JavaScript'in `Date.now()` fonksiyonu, Java'nın `System.currentTimeMillis()` çağrısı, Node.js, modern JavaScript/TypeScript API'lerinin çoğu, Redis ve birçok veritabanı istemcisi. Bir JSON API yanıtında 13 haneli bir zaman damgası gördüğünüzde neredeyse kesinlikle milisaniyedir. **Mikrosaniye (16 hane)**: Saniyenin milyonda biri hassasiyeti. `1741965432000000`, aynı anın 1.000.000 ile çarpılmış halidir. Kullananlar: PostgreSQL'in `TIMESTAMP` ve `TIMESTAMPTZ` tipleri, Python'un `time.time_ns()` fonksiyonu (her ne kadar bu nanosaniye döndürse de), yüksek frekanslı işlem sistemleri ve ağ paketi analiz araçları. En yaygın hata hassasiyetleri karıştırmaktır — örneğin saniye bekleyen bir fonksiyona milisaniye cinsinden zaman damgası geçirmek. Bu, kabaca 11.574 yıl sonrasındaki tarihler üretir. Üzerinde çalıştığınız API veya sistemin belgelerini her zaman kontrol ederek beklenen hassasiyeti doğrulayın ve bu dönüştürücünün otomatik algılamasını da bir doğrulama aracı olarak kullanın.
Unix zamanı artık saniyeleri hesaba katar mı?
Hayır — Unix zamanı artık saniyeleri hesaba katmaz ve bu, yüksek hassasiyetli zaman tutma uygulamaları açısından bilinen kısıtlamalarından biridir. Artık saniyeler, UTC'yi Dünya'nın hafifçe düzensiz dönüşüyle senkronize tutmak için Uluslararası Yer Dönüşü ve Referans Sistemleri Servisi (IERS) tarafından zaman zaman eklenir (ya da teorik olarak çıkarılır, fakat şimdiye kadar hiç çıkarılmamıştır). 2026 itibarıyla, 1972'de ilk kez tanıtıldıklarından bu yana 27 artık saniye eklenmiştir. Unix zamanı, bir günün tam olarak 86.400 saniyeden (24 × 60 × 60) oluştuğu, kusursuz biçimde düzenli bir takvimi varsayar. Bir artık saniye eklendiğinde, gerçek dünyada Unix zamanının yok saydığı bir saniye olur. İşletim sistemleri bunu farklı şekillerde ele alır: Linux geleneksel olarak ekleme noktası çevresinde saati bir süre boyunca yavaş çalıştırarak artık saniyeyi "yayar" (Google'ın yaklaşımı; aynı zamanda "leap smearing" olarak da bilinir); bazı sistemler 23:59:60 UTC'deki saniyeyi çiftler; bazıları ise düzeltmeyi tamamen atlar ve saatin kaymasına izin verir. Software uygulamalarının büyük çoğunluğu için — web servisleri, API'ler, veritabanları, iş mantığı — 50+ yılda biriken yaklaşık 27 saniyelik artık saniye farkı tamamen önemsizdir. Fark, kullanıcıya yönelik herhangi bir uygulamada hissedilmez. Artık saniyelerin önemli olduğu yerler: GPS senkronizasyonu, astronomik gözlem, paket ağ zamanlama protokolleri (PTP/IEEE 1588) ve Unix zaman damgalarının TAI (Uluslararası Atom Zamanı) ile tam olarak eşleştirilmesi gereken her sistem. Uygulamanız bu kategorilere giriyorsa, artık saniye farkındalığını açıkça destekleyen bir zaman tutma kütüphanesi kullanmalı veya doğrudan TAI zaman damgalarıyla çalışmalısınız.
Unix zaman damgaları negatif olabilir mi?
Evet, Unix zaman damgaları negatif olabilir; negatif zaman damgaları Unix epoch'undan (1 Ocak 1970 00:00:00 UTC) önceki tarihleri temsil etmenin meşru ve iyi tanımlanmış bir yoludur. Epoch'tan önceki her saniye, sıfırdan 1 azaltmaya karşılık gelir. Örneğin -1, 31 Aralık 1969 23:59:59 UTC'yi; -86400, 31 Aralık 1969 00:00:00 UTC'yi (epoch'tan tam bir gün önce); -2208988800 ise 1 Ocak 1900 00:00:00 UTC'yi temsil eder. Günümüz programlama dillerinin ve işletim sistemlerinin çoğu negatif zaman damgalarını destekler. Python'un `datetime.fromtimestamp(-86400)` çağrısı 31 Aralık 1969'u doğru biçimde döndürür. JavaScript'in `new Date(-86400 * 1000)` ifadesi aynı tarihi doğru oluşturur. PostgreSQL, zaman damgalarını 8 baytlık tamsayılar olarak saklar ve epoch'tan binlerce yıl önceki tarihleri doğru biçimde işler. Bununla birlikte önemli uyarılar vardır. Bazı eski sistemler, kütüphaneler veya veritabanı sürücüleri negatif zaman damgalarını doğru desteklemeyebilir. Zaman damgaları için işaretsiz tamsayı kullanan 32 bit sistemler negatif değerleri hiç temsil edemez. UNSIGNED BIGINT veya DATETIME türleriyle tanımlanan bazı veritabanları ise negatif değerleri reddedebilir ya da çok uzak gelecekteki tarihler olarak yorumlayabilir. Tarihsel tarihler için (1970 öncesindeki her şey) tarih bilgisini ISO 8601 dizesi olarak ya da veritabanına özgü bir tarih türü ile saklamak, taşınabilirlik açısından negatif Unix zaman damgalarına güvenmekten çoğunlukla daha güvenlidir. Bu dönüştürücü negatif zaman damgalarını doğru biçimde işler ve karşılık gelen 1970 öncesi tarihi gösterir.
JavaScript, Python veya başka dillerde güncel Unix zaman damgasını nasıl alırım?
Güncel Unix zaman damgasını almak her büyük programlama dilinde basittir: **JavaScript / TypeScript:** ```javascript // Saniye (çoğu API bunu bekler) const seconds = Math.floor(Date.now() / 1000); // Milisaniye (JavaScript yerel) const milliseconds = Date.now(); ``` **Python:** ```python import time seconds = int(time.time()) # 1741965432 import datetime milliseconds = int(datetime.datetime.now(datetime.UTC).timestamp() * 1000) ``` **Go:** ```go import "time" seconds := time.Now().Unix() // int64 milliseconds := time.Now().UnixMilli() // int64 microseconds := time.Now().UnixMicro() // int64 ``` **Java:** ```java long seconds = System.currentTimeMillis() / 1000L; long milliseconds = System.currentTimeMillis(); // Veya java.time ile (Java 8+): long seconds2 = Instant.now().getEpochSecond(); ``` **PHP:** ```php $seconds = time(); // integer $milliseconds = round(microtime(true) * 1000); ``` **Ruby:** ```ruby seconds = Time.now.to_i milliseconds = (Time.now.to_f * 1000).to_i ``` **Bash / Shell:** ```bash date +%s # saniye date +%s%3N # milisaniye (GNU date) ``` Unutulmaması gereken en önemli şey: JavaScript yerel olarak milisaniye ile çalışırken, neredeyse her başka dil varsayılan olarak saniye kullanır. Hangi hassasiyeti kullandığınız konusunda her zaman açık olun ve entegrasyon hatalarını önlemek için bunu API sözleşmelerinizde belgeleyin.
Epoch zamanını insan tarafından okunabilir bir tarihe nasıl dönüştürürüm?
Epoch zamanını (Unix zaman damgalarını) insan tarafından okunabilir bir tarihe dönüştürmenin üç hızlı yolu vardır: **1. Bu çevrimiçi dönüştürücüyü kullanın (en hızlı)** Epoch zaman damganızı yukarıdaki giriş alanına yapıştırın. Araç, değerin saniye, milisaniye veya mikrosaniye cinsinden olduğunu otomatik algılar ve sonucu UTC, yerel saat diliminiz, ISO 8601 ve göreli zaman biçimlerinde anında gösterir. Herhangi bir biçimi almak için Kopyala'ya tıklayın. **2. Kod kullanın** JavaScript'te: `new Date(1741965432 * 1000).toISOString()` ifadesi `'2025-03-14T15:37:12.000Z'` döndürür. Python'da: `from datetime import datetime, UTC; datetime.fromtimestamp(1741965432, UTC)` aynı sonucu verir. JavaScript'in milisaniye, Python'un ise saniye beklediğine dikkat edin — bu, dönüşüm hatalarının en yaygın kaynağıdır. **3. Komut satırını kullanın** GNU date'in olduğu Linux veya macOS'ta: `date -d @1741965432` (Linux) veya `date -r 1741965432` (macOS). Windows PowerShell'de: `[DateTimeOffset]::FromUnixTimeSeconds(1741965432).DateTime`. Üç yöntem de aynı sonucu üretir. Yukarıdaki çevrimiçi dönüştürücü, terminal açmadan veya kod yazmadan hızlı bir cevap istediğinizde en hızlı seçenektir.
Şu anki Unix zaman damgası nedir?
Güncel Unix zaman damgası, bu sayfanın üst kısmındaki canlı saatte gösterilir ve her saniye güncellenir. Unix zaman damgası, basitçe 1 Ocak 1970 00:00:00 UTC'den bu yana geçen saniyelerin sayısıdır ve her saniye tam olarak 1 artar. Güncel zaman damgasını programlı şekilde almak için: - **JavaScript**: `Math.floor(Date.now() / 1000)` (saniye) veya `Date.now()` (milisaniye) - **Python**: `import time; int(time.time())` - **Bash**: `date +%s` 2026 itibarıyla, güncel Unix zaman damgası 1,77 milyar civarındadır (10 hane). 2033'ün Mayıs ayı dolaylarında 2 milyara ulaşacak ve 32 bitlik sistemler için maksimum değer (2.147.483.647) 19 Ocak 2038 03:14:07 UTC'de — yani sözde 2038 Yılı sorunu anında — tamamlanacaktır. Güncel epoch zamanını her zaman tek tıkla almak için bu sayfayı yer imlerinize ekleyin.
API yanıtımdaki bir zaman damgasını ayıklamam gerekiyor — nasıl dönüştürürüm?
API yanıtınızdaki zaman damgası değerini kopyalayın (genellikle "created_at" veya "timestamp" gibi bir JSON alanında 10 ya da 13 haneli bir sayı olur). Doğrudan yukarıdaki giriş alanına yapıştırın — araç, değerin saniye veya milisaniye olduğunu otomatik algılar ve UTC tarihini, yerel saatinizi ve ISO 8601 biçimini anında gösterir. Zaman damgası bir JWT token'ının içinde gömülüyse, iat, exp veya nbf alanlarını çıkarmak için önce JWT yükünü (Base64URL ile kodlanmıştır) çözün ve ardından bu değerleri buraya yapıştırın. Toplu ayıklama için kod parçacığını kullanın: tarayıcı konsolunuzda new Date(timestamp * 1000).toISOString() ile birden fazla zaman damgasını geliştirici araçlarından çıkmadan hızla kontrol edebilirsiniz.
Python/JavaScript/Go'da güncel Unix zaman damgasını nasıl alırım?
JavaScript'te saniye için Math.floor(Date.now() / 1000), milisaniye için Date.now() kullanın. Python'da saniye için import time; int(time.time()), milisaniye için int(time.time() * 1000) kullanın. Go'da saniye için time.Now().Unix(), milisaniye için time.Now().UnixMilli(), mikrosaniye için time.Now().UnixMicro() kullanın. JavaScript'in yerel olarak milisaniye ile çalıştığını, Python ve Go'nun ise varsayılan olarak saniye kullandığını unutmayın — bu, farklı dillerle yazılmış sistemleri entegre ederken zaman damgası hatalarının en yaygın tek kaynağıdır. API'nizin hangi hassasiyeti beklediğini her zaman OpenAPI/Swagger belgenizde belirtin.
Yaz saati uygulaması geçişlerinde Unix zaman damgalarına ne olur?
Unix zaman damgaları, UTC'ye dayalı oldukları ve UTC yaz saati uygulaması (DST) gözetmediği için DST geçişlerinden tamamen etkilenmez. Yerel bir saat diliminde saatler "ileri alındığında" veya "geri alındığında" Unix zaman damgası, aralık veya tekrar olmaksızın saniyede tam olarak 1 artmaya devam eder. Bu, zamanı yerel datetime dizeleri yerine Unix zaman damgası olarak saklamanın temel avantajlarından biridir. Ancak DST geçişi sırasında bir Unix zaman damgasını yerel saate dönüştürürseniz, aynı yerel saat iki farklı Unix zaman damgasına karşılık gelebilir (saatlerin tekrarlandığı "geri alma" saatinde). Zaman damgalarını her zaman UTC olarak saklayın ve karşılaştırın; yerel saate yalnızca görüntüleme amacıyla dönüştürün.
Milisaniye cinsinden bir zaman damgam var — saniyeye nasıl dönüştürürüm?
Milisaniye zaman damgasını 1000'e bölün ve ondalık kısmı atın. JavaScript'te: Math.floor(ms / 1000). Python'da: ms // 1000 (tamsayı bölmesi). Örneğin 1741965432000 (milisaniye) değeri 1741965432 (saniye) haline gelir. Milisaniye zaman damgalarını 13 haneli uzunluklarından, saniyeleri ise 10 haneli uzunluklarından tanıyabilirsiniz. Bu araç hassasiyeti otomatik algılar; bu nedenle her iki biçimi de doğrudan yapıştırabilirsiniz. Ters dönüşüm (saniyeden milisaniyeye) ise basitçe 1000 ile çarpmaktır: 1741965432 * 1000 = 1741965432000. Milisaniye değerini, saniye bekleyen bir fonksiyona yanlışlıkla geçirmemeye dikkat edin — sonuç kabaca 11.574 yıl sonrasındaki bir tarih olur.

İlgili Araçlar

Tüm araçları görüntüleyin →

Sayı Tabanı Dönüştürücü — Binary, Hex, Decimal ve Octal

Dönüştürme Araçları

Binary, hex, decimal, octal ve herhangi bir taban (2-36) arasında anında dönüştürün. Ücretsiz ve gizli — tüm işlem tarayıcınızda yapılır.

Base64 Çözücü ve Kodlayıcı

Kodlama ve Biçimlendirme

Base64'ü ücretsiz çevrimiçi kodlayın ve çözün. Tam UTF-8 ve emoji desteğiyle gerçek zamanlı dönüştürme. %100 tarayıcıda — kayıt gerekmez.

Resimleri Çevrimiçi Sıkıştırın — JPEG, PNG ve WebP

Dönüştürme Araçları

JPEG, PNG ve WebP'yi %80'e kadar küçültün — tarayıcınızda, yükleme yok. 20 resim toplu, kalite ayarı, öncesi/sonrası karşılaştırma. Ücretsiz ve gizli.

JSON Biçimlendirici ve Doğrulayıcı

Kodlama ve Biçimlendirme

JSON'u tarayıcınızda anında biçimlendirin, doğrulayın ve güzelleştirin. Sözdizimi denetimi, hata tespiti, sıkıştırma ve tek tıkla kopyalama. %100 gizli.

JWT Çözücü

Güvenlik Araçları

Ücretsiz JWT çözücümüzle JWT token'larını online çözün. header, payload, signature, son kullanma, algoritma ve claim'leri anında inceleyin. %100 tarayıcıda çalışır — token'ınız cihazınızdan ayrılmaz. Kayıt yok, izleme yok.

Uzunluk Dönüştürücü — Metrik, İmperyal ve Daha Fazlası

Dönüştürme Araçları

16 uzunluk birimini anında dönüştürün — metrik, imperyal, denizcilik ve astronomik. 1 inç = 2,54 cm. Ücretsiz, gizli, tarayıcınızda çalışır.