Time di Golang: Now, Sleep, Format, Parse, dan Duration

Dasarnya dalam satu program

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() mengembalikan waktu lokal saat ini, time.Sleep menjeda goroutine yang sedang berjalan, time.Since mengukur waktu yang sudah berlalu, dan time.Date membangun sebuah momen tertentu. Bagian selanjutnya di halaman ini membahas setiap bagian satu per satu. Contoh-contohnya memakai tanggal tetap dan UTC, sehingga output-nya sama di mana pun kamu menjalankannya.

Sleep dan Duration

time.Duration adalah int64 yang menghitung nanodetik. Package ini mendefinisikan konstanta untuk membuat nilai yang mudah dibaca:

Tidak ada time.Day, karena satu hari tidak selalu 24 jam ketika zona waktu berganti untuk daylight saving. Pakai AddDate untuk hari kalender (lihat di bawah).

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

Ada dua bug umum yang muncul karena Duration adalah integer:

• time.Sleep(5) tidur selama 5 nanodetik. Selalu kalikan dengan satuan: time.Sleep(5 * time.Second).
• time.Sleep(n * time.Second) tidak bisa dikompilasi kalau n adalah variabel int. Konversikan: time.Duration(n) * time.Second. Konstanta seperti 5 bisa dipakai tanpa konversi karena konstanta tanpa tipe menyesuaikan diri dengan tipe Duration.

ParseDuration menerima ns, us (atau µs), ms, s, m, dan h, yang bisa digabung seperti "2h45m" atau "1.5s". Tidak ada satuan untuk hari.

Format: layout acuan 2006-01-02

Go tidak memakai %Y-%m-%d atau yyyy-MM-dd. Layout adalah waktu acuan

Mon Jan 2 15:04:05 MST 2006

yang ditulis sesuai bentuk output yang kamu inginkan. Nilai-nilainya dipilih agar masing-masing unik: bulan 1, tanggal 2, jam 3 (atau 15), menit 4, detik 5, tahun 6 (2006), offset zona -7 (-0700). Bacalah sebagai 01/02 03:04:05PM '06 -0700.

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

Token layout yang paling sering kamu butuhkan:

Layout yang sudah tersedia:

Kesalahan klasiknya adalah menulis layout dengan angka yang salah, misalnya "2023-01-01". Go tidak menolaknya. Go menyalin karakter yang tidak ia kenali dan mengganti karakter yang ia kenali: setiap 2 adalah tanggal, 3 adalah jam dalam format 12 jam, dan kedua 01 adalah bulan, jadi 5 Maret pukul 9.07 diformat menjadi 5059-03-03. Layout seperti "YYYY-MM-DD" sama sekali tidak berisi token, jadi dicetak apa adanya. Kalau tanggal yang diformat terlihat aneh, periksa apakah layout-nya memakai nilai acuan dengan tepat.

Parse string menjadi waktu

time.Parse(layout, value) memakai layout yang sama, dan mengembalikan error yang wajib kamu periksa:

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

Kalau input-nya tidak berisi zona, Parse mengembalikan UTC. String jam dinding yang sama bisa berarti momen yang berbeda tergantung zonanya, dan itulah alasan ParseInLocation ada. Pesan error-nya menyebut bagian yang gagal dicocokkan, yang membantu saat kamu sedang debug layout.

Zona waktu

time.Time adalah sebuah momen ditambah lokasi yang dipakai untuk tampilan. Mengganti lokasi dengan In mengubah cara waktu itu dicetak, bukan momennya.

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 selalu tersedia. Simpan dan kirim waktu dalam UTC (atau RFC 3339 dengan offset), dan konversikan hanya untuk tampilan.
• time.Local adalah zona milik mesin. Di server dan container, zona ini sering UTC, sedangkan di laptop tidak, jadi kode yang bergantung padanya berperilaku berbeda di setiap tempat.
• time.LoadLocation("Europe/Berlin") membaca database IANA dari sistem operasi. Image container yang minimal sering tidak memilikinya, dan panggilan itu lalu mengembalikan error. Blank import _ "time/tzdata" menanamkan database tersebut ke binary-mu (sekitar 450 KB) sehingga selalu berhasil. Selalu tangani error-nya.
• time.FixedZone(name, offsetSeconds) membuat zona dengan offset tetap. Zona ini tidak punya aturan daylight saving, jadi pakai untuk offset yang kamu terima, bukan untuk wilayah bernama.

Aritmetika dan perbandingan

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())
}

Hal yang perlu diperhatikan di output-nya:

• AddDate(0, 1, 0) pada 31 Januari menghasilkan 3 Maret, bukan 28 Februari. Go menambahkan satu bulan sehingga menjadi "31 Februari", lalu menormalkan kelebihannya. Kalau kamu butuh "tanggal yang sama bulan depan, dibatasi sampai akhir bulan", tulis logikanya sendiri.
• Sub mengembalikan Duration, yang batas maksimalnya sekitar 292 tahun. Untuk selisih dalam hari kalender, bandingkan tanggal pada tengah malam UTC dan bagi dengan 24 jam.
• Untuk mendapatkan awal hari, bangun ulang waktunya dari Date(). t.Truncate(24 * time.Hour) membulatkan relatif terhadap zero time dalam UTC, jadi hasilnya salah untuk zona apa pun selain UTC.

Bandingkan dengan Equal, Before, After, jangan pernah dengan ==. time.Now() menyertakan pembacaan jam monotonik, yang dipakai agar time.Since tetap benar kalau jam dinding disesuaikan. == ikut membandingkan pembacaan itu dan lokasinya, jadi dua nilai Time untuk momen yang sama bisa dianggap tidak sama. Dengan alasan yang sama, jangan pakai time.Time sebagai key map tanpa menormalkannya lebih dulu (t.UTC().Round(0) membuang pembacaan monotoniknya).

Zero value time.Time adalah 1 Januari tahun 1, pukul 00.00 UTC. Periksa dengan t.IsZero().

Mengukur waktu yang berlalu

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

time.Since(start) sama dengan time.Now().Sub(start), dan time.Until(deadline) sama dengan deadline.Sub(time.Now()). Keduanya memakai jam monotonik jika tersedia, jadi aman dari perubahan jam sistem. Untuk benchmark kode, pakai dukungan benchmark Go di package testing, bukan mengukur waktu secara manual.

Timer dan ticker

time.After(d) mengembalikan channel yang menerima satu kali setelah d. time.Timer adalah hal yang sama dengan tambahan method Stop. time.Ticker mengirim sebuah nilai setiap periode sampai kamu menghentikannya.

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

Tiga tick pada 20, 40, dan 60 ms tiba jauh sebelum timer 110 ms, jadi program berhenti setelah tick ketiga. time.AfterFunc(d, f) menjalankan f di goroutine-nya sendiri setelah d, yang praktis untuk pekerjaan tertunda yang hanya sekali.

Sejak Go 1.23, timer dan ticker yang sudah tidak direferensikan akan di-garbage collect walaupun kamu tidak pernah memanggil Stop, dan channel dari timer yang sudah dihentikan atau di-reset tidak lagi mengirim nilai basi. Memanggil Stop dengan defer tetap menjadi cara yang jelas untuk menyatakan bahwa masa hidup ticker sudah selesai. Kalau batas waktu berlaku untuk seluruh operasi, bukan hanya satu penantian, context.WithTimeout biasanya lebih enak dibaca daripada timer.

Waktu di JSON

time.Time otomatis di-marshal ke dan dari string RFC 3339 di JSON, dengan presisi nanodetik:

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

String JSON dalam format lain akan gagal di-unmarshal. Untuk timestamp Unix atau format khusus, simpan int64 atau string lalu konversikan, atau definisikan tipe dengan UnmarshalJSON miliknya sendiri.

Kesalahan umum

• time.Sleep(1) atau time.Sleep(n) dengan angka polos. Itu dalam nanodetik.
• Layout dengan digit yang salah. "2023-01-01" atau "YYYY-MM-DD" bukan layout. Pakai "2006-01-02".
• Tertukar antara menit dan bulan. Menit adalah 04, bulan adalah 01. "15:01" mencetak jam lalu bulan, bukan menit.
• Membandingkan dengan ==. Pakai Equal.
• Mengandalkan time.Local. Nilainya berbeda di setiap mesin. Tulis secara eksplisit dengan time.UTC atau lokasi yang sudah dimuat.
• Mengabaikan error dari LoadLocation atau Parse. Keduanya bisa gagal pada input sungguhan. Parse yang gagal mengembalikan zero time, yang tercetak sebagai tahun 1, dan LoadLocation yang gagal mengembalikan lokasi nil yang membuat t.In(loc) panic.