Le package time

Le package time modélise trois concepts distincts : instants (time.Time), durées (time.Duration) et instruments périodiques (minuteries, tickers). Les distinguer est crucial : un instant est un point sur la chronologie, une durée est un intervalle.

time.Time — instants

now := time.Now()                // istante corrente nel fuso locale
utc := now.UTC()                 // stesso istante in UTC
later := now.Add(2 * time.Hour)  // somma una durata
diff := later.Sub(now)           // 2h0m0s (è una Duration)

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

time.Time est immuable : toutes les méthodes Add, Truncate, Round renvoient un nouveau Time.

Pour comparer les instants, utilisez Before, After, Equal. N'utilisez pas == si les instants peuvent avoir des horloges de zone/monotones différentes.

time.Duration — intervalles

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

const timeout = 5 * time.Second

time.Duration est un alias de int64 qui compte les nanosecondes. Les constantes time.Nanosecond, time.Microsecond, time.Millisecond, time.Second, time.Minute, time.Hour sont de type Duration.

Analyse et formatage : la mise en page de référence

Go n'utilise pas de chaînes de style YYYY-MM-DD. Utilisez un instant de référence canonique :

Mon Jan 2 15:04:05 MST 2006

c'est-à-dire 01/02 03:04:05PM '06 -0700. En mémorisant cette disposition (mnémonique : 1-2-3-4-5-6-7) vous pouvez formater n'importe quelle date :

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

La stdlib propose des mises en page prêtes à l'emploi : time.RFC3339 ("2006-01-02T15:04:05Z07:00"), time.RFC1123, time.Kitchen ("3:04PM").

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

Mesurer le temps

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

time.Since utilise une horloge monotone : elle n'est pas perturbée par les réglages de l'horloge système (NTP, heure d'été). Pour les mesures de performances, c'est ce que vous voulez.

Minuteurs et tickers

• time.After(d) renvoie un chan time.Time qui reçoit une seule fois après d. Utile dans select :

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

• time.NewTimer(d) est une variante arrêtable (t.Stop()).
• time.NewTicker(d) envoie à plusieurs reprises chaque d. N'oubliez pas defer ticker.Stop() pour éviter les fuites goroutines.

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

Exercices

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