`సమయం` ప్యాకేజీ

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 2 రకానికి చెందినవి.

పార్సింగ్ మరియు ఫార్మాటింగ్: సూచన లేఅవుట్

Go 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 మోనోటోనిక్ గడియారాన్ని ఉపయోగిస్తుంది: ఇది సిస్టమ్ క్లాక్ సర్దుబాట్లు (NTP, డేలైట్ సేవింగ్) ద్వారా కలవరపడదు. పనితీరు కొలతల కోసం అది మీకు కావలసినది.

టైమర్ మరియు టిక్కర్

• time.After(d) d తర్వాత మాత్రమే ఒక్కసారిని స్వీకరించే chan time.Timeని అందిస్తుంది. 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 ???