Golang Time: Now, Sleep, Format, Parse ve Duration'lar

Tek programda temeller

package main

import (
	"fmt"
	"time"
)

func main() {
	start := time.Now()

	time.Sleep(50 * time.Millisecond)

	elapsed := time.Since(start)
	fmt.Println("slept at least 50ms:", elapsed >= 50*time.Millisecond)

	t := time.Date(2026, time.September, 23, 14, 30, 0, 0, time.UTC)
	fmt.Println(t)
	fmt.Println(t.Format("2006-01-02 15:04"))
	fmt.Println(t.Format("Monday, January 2, 2006"))
	fmt.Println("in 90 minutes:", t.Add(90*time.Minute).Format(time.Kitchen))
}

time.Now() mevcut yerel zamanı döndürür, time.Sleep mevcut goroutine'i duraklatır, time.Since geçen süreyi ölçer, time.Date ise belirli bir anı oluşturur. Bu sayfanın geri kalanı her parçayı sırayla ele alıyor. Örnekler, çıktıları nerede çalıştırırsanız çalıştırın aynı olsun diye sabit tarihler ve UTC kullanır.

Sleep ve Duration

Bir time.Duration, nanosaniye sayan bir int64'tür. Paket okunabilir değerler oluşturmak için sabitler tanımlar:

time.Day yoktur, çünkü bir saat dilimi yaz saati için değiştiğinde bir gün her zaman 24 saat değildir. Takvim günleri için AddDate kullanın (aşağıya bakın).

package main

import (
	"fmt"
	"time"
)

func main() {
	d := 90 * time.Minute
	fmt.Println(d)                      // 1h30m0s
	fmt.Println(d.Hours(), d.Minutes()) // float64 values
	fmt.Println(2*time.Hour + 15*time.Second)

	// Multiplying by a variable needs a conversion: int * Duration does not compile.
	retries := 3
	backoff := time.Duration(retries) * 200 * time.Millisecond
	fmt.Println("backoff:", backoff)

	// Parse a duration from a string (for flags and config files).
	timeout, err := time.ParseDuration("1m30s")
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Println("timeout:", timeout, "=", timeout.Seconds(), "seconds")

	// Round and truncate a measured duration for display.
	measured := 1234567891 * time.Nanosecond
	fmt.Println(measured, measured.Round(time.Millisecond), measured.Truncate(time.Second))
}

İki yaygın hata Duration'ın bir tam sayı olmasından gelir:

• time.Sleep(5) 5 nanosaniye bekler. Her zaman bir birimle çarpın: time.Sleep(5 * time.Second).
• n bir int değişkeni olduğunda time.Sleep(n * time.Second) derlenmez. Dönüştürün: time.Duration(n) * time.Second. 5 gibi bir sabit dönüşüm olmadan çalışır, çünkü tipsiz sabitler Duration tipine uyum sağlar.

ParseDuration; ns, us (ya da µs), ms, s, m ve h birimlerini "2h45m" ya da "1.5s" gibi birleşik olarak kabul eder. Gün için birimi yoktur.

Biçimlendirme: 2006-01-02 referans düzeni

Go, %Y-%m-%d ya da yyyy-MM-dd kullanmaz. Bir düzen, referans zamanının

Mon Jan 2 15:04:05 MST 2006

çıktınızın görünmesini istediğiniz şekilde yazılmış halidir. Değerler her biri benzersiz olacak şekilde seçilmiştir: ay 1, gün 2, saat 3 (ya da 15), dakika 4, saniye 5, yıl 6 (2006), dilim farkı -7 (-0700). Onu 01/02 03:04:05PM '06 -0700 olarak okuyun.

package main

import (
	"fmt"
	"time"
)

func main() {
	t := time.Date(2026, time.March, 5, 9, 7, 3, 250_000_000, time.UTC)

	layouts := []string{
		"2006-01-02",
		"02/01/2006",
		"01/02/06",
		"Jan 2, 2006",
		"Monday 2 January 2006",
		"15:04:05",
		"3:04 PM",
		"2006-01-02T15:04:05.000Z07:00",
		time.RFC3339,
		time.DateTime,
		time.RFC1123,
	}
	for _, l := range layouts {
		fmt.Printf("%-32q %s\n", l, t.Format(l))
	}
}

En çok ihtiyaç duyacağınız düzen token'ları:

Önceden tanımlı düzenler:

Klasik hata, bir düzeni yanlış sayılarla yazmaktır, örneğin "2023-01-01". Go bunu reddetmez. Tanımadığı karakterleri kopyalar, tanıdıklarını ise yerine koyar: her 2 gündür, 3 12 saatlik saattir ve iki 01 de aydır, bu yüzden 5 Mart saat 9:07 5059-03-03 olarak biçimlendirilir. "YYYY-MM-DD" gibi bir düzen hiç token içermez ve kendini değiştirmeden yazdırır. Biçimlendirilmiş tarihler tuhaf görünüyorsa düzenin tam olarak referans değerlerini kullandığını kontrol edin.

String'leri zamana ayrıştırmak

time.Parse(layout, value) aynı düzenleri kullanır ve kontrol etmeniz gereken bir hata döndürür:

package main

import (
	"fmt"
	"time"
)

func main() {
	t, err := time.Parse("2006-01-02 15:04", "2026-09-23 18:45")
	if err != nil {
		fmt.Println("parse error:", err)
		return
	}
	fmt.Println(t, "| location:", t.Location())

	// A string with an offset keeps that offset.
	t2, err := time.Parse(time.RFC3339, "2026-09-23T18:45:00+02:00")
	if err != nil {
		fmt.Println("parse error:", err)
		return
	}
	fmt.Println(t2, "| in UTC:", t2.UTC())

	// Interpret a zone-less string in a specific zone.
	tokyo := time.FixedZone("JST", 9*60*60)
	t3, err := time.ParseInLocation(time.DateTime, "2026-09-23 18:45:00", tokyo)
	if err != nil {
		fmt.Println("parse error:", err)
		return
	}
	fmt.Println(t3, "| in UTC:", t3.UTC())

	// A wrong input produces a descriptive error.
	_, err = time.Parse(time.DateOnly, "23/09/2026")
	fmt.Println("error:", err)
}

Girdide dilim yoksa Parse UTC döndürür. Aynı duvar saati string'i dilime göre farklı anlar ifade edebilir; ParseInLocation'ın var olmasının nedeni budur. Hata mesajı eşleşmeyen kısmı adlandırır; bu da bir düzende hata ayıklarken yardımcı olur.

Saat dilimleri

Bir time.Time, bir an artı gösterim için kullanılan bir konumdur. Konumu In ile değiştirmek hangi an olduğunu değil, nasıl yazdırıldığını değiştirir.

package main

import (
	"fmt"
	"time"
	_ "time/tzdata" // embed the zone database so LoadLocation works anywhere
)

func main() {
	meeting := time.Date(2026, time.September, 23, 15, 0, 0, 0, time.UTC)

	ny, err := time.LoadLocation("America/New_York")
	if err != nil {
		fmt.Println("load location:", err)
		return
	}
	india := time.FixedZone("IST", 5*60*60+30*60) // +05:30, no DST rules

	fmt.Println("UTC:     ", meeting.Format(time.RFC1123))
	fmt.Println("New York:", meeting.In(ny).Format(time.RFC1123))
	fmt.Println("India:   ", meeting.In(india).Format(time.RFC1123))
	fmt.Println("same instant:", meeting.Equal(meeting.In(ny)))
}

• time.UTC her zaman kullanılabilir. Zamanları UTC olarak (ya da bir farkla RFC 3339 olarak) saklayın ve iletin, yalnızca gösterim için dönüştürün.
• time.Local makinenin dilimidir. Sunucularda ve container'larda çoğu zaman UTC'dir, dizüstü bilgisayarda değildir; bu yüzden ona bağlı kod her yerde farklı davranır.
• time.LoadLocation("Europe/Berlin") IANA veritabanını işletim sisteminden okur. Minimal container imajlarında çoğu zaman yoktur ve çağrı o zaman bir hata döndürür. Boş import _ "time/tzdata" veritabanını binary'nize gömer (yaklaşık 450 KB), böylece her zaman çalışır. Hatayı her zaman ele alın.
• time.FixedZone(name, offsetSeconds) sabit farklı bir dilim oluşturur. Yaz saati kuralları yoktur, bu yüzden onu adlandırılmış bölgeler için değil, aldığınız farklar için kullanın.

Aritmetik ve karşılaştırma

package main

import (
	"fmt"
	"time"
)

func main() {
	start := time.Date(2026, time.January, 31, 10, 0, 0, 0, time.UTC)
	end := time.Date(2026, time.March, 1, 12, 30, 0, 0, time.UTC)

	fmt.Println("difference:", end.Sub(start))
	fmt.Println("in days:   ", int(end.Sub(start).Hours()/24))

	fmt.Println("+36h:      ", start.Add(36*time.Hour).Format(time.DateTime))
	fmt.Println("-1 week:   ", start.AddDate(0, 0, -7).Format(time.DateOnly))
	fmt.Println("+1 month:  ", start.AddDate(0, 1, 0).Format(time.DateOnly)) // Jan 31 + 1 month

	fmt.Println("before:", start.Before(end), "after:", start.After(end), "equal:", start.Equal(end))

	// Start of the day, and parts of a date.
	y, m, d := end.Date()
	midnight := time.Date(y, m, d, 0, 0, 0, 0, end.Location())
	fmt.Println("midnight:", midnight.Format(time.DateTime))
	fmt.Println("weekday:", end.Weekday(), "day of year:", end.YearDay())

	// Unix timestamps.
	fmt.Println("unix:", start.Unix(), "ms:", start.UnixMilli())
	fmt.Println("from unix:", time.Unix(1_790_000_000, 0).UTC())
}

Çıktıda dikkat edilecekler:

• 31 Ocak'ta AddDate(0, 1, 0), 28 Şubat değil 3 Mart verir. Go bir ay ekleyerek "31 Şubat"ı elde eder ve sonra taşmayı normalleştirir. "Gelecek ay aynı gün, sınırlandırılmış" istiyorsanız o mantığı kendiniz yazın.
• Sub bir Duration döndürür ve bu yaklaşık 292 yılda tavan yapar. Takvim günü farkları için tarihleri UTC gece yarısında karşılaştırın ve 24 saate bölün.
• Günün başlangıcını almak için zamanı Date()'ten yeniden oluşturun. t.Truncate(24 * time.Hour) UTC'deki sıfır zamana göre yuvarlar, bu yüzden UTC dışındaki her dilim için yanlış cevap verir.

== ile değil, Equal, Before, After ile karşılaştırın. time.Now() bir monotonik saat okuması içerir; bu, duvar saati ayarlansa bile time.Since'in doğru kalması için kullanılır. == bu okumayı ve konumu da karşılaştırır, bu yüzden aynı ana ait iki Time değeri eşit olmayabilir. Aynı nedenle, önce normalleştirmeden time.Time'ı map anahtarı olarak kullanmayın (t.UTC().Round(0) monotonik okumayı kaldırır).

Sıfır değerli time.Time, 1. yılın 1 Ocak'ı, 00:00 UTC'dir. Onu t.IsZero() ile kontrol edin.

Geçen süreyi ölçmek

start := time.Now()
doWork()
log.Printf("doWork took %v", time.Since(start))

time.Since(start), time.Now().Sub(start)'tır; time.Until(deadline) ise deadline.Sub(time.Now())'dır. İkisi de mümkün olduğunda monotonik saati kullanır, bu yüzden sistem saati değişikliklerine karşı güvenlidir. Kod benchmark'ı için elle zamanlamak yerine testing paketindeki Go'nun benchmark desteğini kullanın.

Timer'lar ve ticker'lar

time.After(d), d'den sonra bir kez değer alan bir channel döndürür. Bir time.Timer, Stop metodu olan aynı şeydir. Bir time.Ticker siz durdurana kadar her periyotta bir değer iletir.

package main

import (
	"fmt"
	"time"
)

func main() {
	ticker := time.NewTicker(20 * time.Millisecond)
	defer ticker.Stop()

	done := time.NewTimer(110 * time.Millisecond)
	defer done.Stop()

	ticks := 0
	for {
		select {
		case <-ticker.C:
			ticks++
			fmt.Println("tick", ticks)
			if ticks == 3 {
				fmt.Println("got three ticks, stopping early")
				return
			}
		case <-done.C:
			fmt.Println("timer fired first")
			return
		}
	}
}

20, 40 ve 60 ms'deki üç tick 110 ms'lik timer'dan çok önce gelir, bu yüzden program üçüncü tick'ten sonra durur. time.AfterFunc(d, f), f'yi d'den sonra kendi goroutine'inde çalıştırır; bu da tek seferlik gecikmeli işler için kullanışlıdır.

Go 1.23'ten beri artık başvurulmayan timer'lar ve ticker'lar, Stop hiç çağrılmasa bile çöp toplayıcı tarafından toplanır ve durdurulmuş ya da sıfırlanmış bir timer'ın channel'ı artık eski bir değer iletmez. Stop'u defer ile çağırmak yine de ticker'ın ömrünün bittiğini söylemenin açık yoludur. Bir zaman sınırı tek bir beklemeye değil bütün bir işleme uygulanıyorsa bir context.WithTimeout genellikle bir timer'dan daha iyi okunur.

JSON'da zaman

time.Time, JSON'da nanosaniye hassasiyetle RFC 3339 string'lerine otomatik olarak dönüşür ve onlardan geri okunur:

type Event struct {
	Name string    `json:"name"`
	At   time.Time `json:"at"`
}
// {"name":"deploy","at":"2026-09-23T14:30:00Z"}

Farklı bir biçimdeki JSON string'i çözülemez. Unix zaman damgaları ya da özel biçimler için bir int64 ya da string saklayıp dönüştürün veya kendi UnmarshalJSON'u olan bir tip tanımlayın.

Sık yapılan hatalar

• Düz bir sayıyla time.Sleep(1) ya da time.Sleep(n). Bu nanosaniyedir.
• Yanlış rakamlı düzenler. "2023-01-01" ya da "YYYY-MM-DD" düzen değildir. "2006-01-02" kullanın.
• Dakika ile ayı karıştırmak. Dakikalar 04, aylar 01'dir. "15:01" dakikayı değil, saati ve ardından ayı yazdırır.
• == ile karşılaştırmak. Equal kullanın.
• time.Local'a güvenmek. Makineler arasında farklıdır. time.UTC ya da yüklenmiş bir konumla açık olun.
• LoadLocation ya da Parse'tan gelen hatayı yok saymak. İkisi de gerçek girdide başarısız olur. Başarısız bir Parse, 1. yıl olarak yazdırılan sıfır zamanı döndürür; başarısız bir LoadLocation ise t.In(loc)'u panic'e sokan nil bir konum döndürür.