'समय' पैकेज

time पैकेज तीन अलग-अलग अवधारणाओं को मॉडल करता है: तत्काल (time.Time), अवधि (time.Duration) और आवधिक उपकरण (टाइमर, टिकर)। उनमें अंतर करना महत्वपूर्ण है: एक क्षण समयरेखा पर एक बिंदु है, एक अवधि एक अंतराल है।

time.Time — क्षण

now := time.Now()                // current instant in the local timezone
utc := now.UTC()                 // same instant in UTC
later := now.Add(2 * time.Hour)  // add a duration
diff := later.Sub(now)           // 2h0m0s (it's a Duration)

fmt.Println(now.Year(), now.Month(), now.Day())
fmt.Println(now.Weekday())

time.Time अपरिवर्तनीय है: सभी विधियाँ Add, Truncate, Round एक नया Time लौटाती हैं।

इंस्टेंट की तुलना करने के लिए Before, After, Equal का उपयोग करें। यदि इंस्टेंट में अलग-अलग समय क्षेत्र/मोनोटोनिक घड़ियां हो सकती हैं तो == का उपयोग न करें।

time.Duration - अंतराल

d := 250 * time.Millisecond
fmt.Println(d)         // 250ms
fmt.Println(d.Seconds()) // 0.25 (float64)

const timeout = 5 * time.Second

time.Duration int64 का उपनाम है जो नैनोसेकंड की गणना करता है। स्थिरांक time.Nanosecond, time.Microsecond, time.Millisecond, time.Second, time.Minute, time.Hour Duration प्रकार के हैं।

पार्सिंग और फ़ॉर्मेटिंग: संदर्भ लेआउट

गो YYYY-MM-DD जैसे स्ट्रिंग्स का उपयोग नहीं करता है। यह कैनोनिकल रेफरेंस इंस्टेंट का उपयोग करता है:

Mon Jan 2 15:04:05 MST 2006

यानि 01/02 03:04:05PM '06 -0700. इस लेआउट को याद करके (स्मरणीय: 1-2-3-4-5-6-7) आप किसी भी तारीख को प्रारूपित कर सकते हैं:

const layout = "2006-01-02 15:04:05"
s := time.Now().Format(layout)            // "2026-05-16 14:30:00"
t, err := time.Parse(layout, "2026-05-16 14:30:00")

stdlib तैयार लेआउट प्रदान करता है: time.RFC3339 ("2006-01-02T15:04:05Z07:00"), time.RFC1123, time.Kitchen ("3:04PM")।

fmt.Println(time.Now().Format(time.RFC3339))

मापन समय

start := time.Now()
work()
elapsed := time.Since(start)  // = time.Now().Sub(start)
fmt.Println("ci ha messo", elapsed)

time.Since मोनोटोनिक घड़ी का उपयोग करता है: यह सिस्टम घड़ी समायोजन (एनटीपी, डेलाइट सेविंग) से परेशान नहीं होता है। प्रदर्शन माप के लिए आप यही चाहते हैं।

टाइमर और टिकर

• time.After(d) एक chan time.Time लौटाता है जो d के बाद केवल एक बार प्राप्त होता है। select में उपयोगी:

select {
case res := <-ch:
    fmt.Println("ok", res)
case <-time.After(2 * time.Second):
    return errors.New("timeout")
}

• time.NewTimer(d) एक रुकने योग्य प्रकार (t.Stop()) है।
• time.NewTicker(d) प्रत्येक d को बार-बार भेजता है। गोरोइन लीक से बचने के लिए defer ticker.Stop() याद रखें।

ticker := time.NewTicker(time.Second)
defer ticker.Stop()
for range ticker.C {
    fmt.Println("tick")
}

अभ्यास

d := time.Second
// d ha tipo ???