0Pricing
Go Academy · Leçon

Les essentiels du package time

Manipuler les heures, les durées et le formatage

Les essentiels du package time est une leçon Go Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Go Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Go Academy comprend 4 leçons au total.

time.Time — Le type central

Le type central du paquet time est time.Time. Obtenez l'heure actuelle avec time.Now() :

package main
import ("fmt"; "time")

func main() {
    now := time.Now()
    fmt.Println(now)              // 2024-01-15 10:30:00.123456789 +0000 UTC
    fmt.Println(now.Year())       // 2024
    fmt.Println(now.Month())      // January
    fmt.Println(now.Day())        // 15
    fmt.Println(now.Hour())       // 10
    fmt.Println(now.Minute())     // 30
    fmt.Println(now.Weekday())    // Monday
}

time.Duration

time.Duration représente une durée écoulée en nanosecondes. Utilisez des constantes typées pour améliorer la lisibilité :

package main
import ("fmt"; "time")

func main() {
    d := 2*time.Hour + 30*time.Minute + 15*time.Second
    fmt.Println(d)              // 2h30m15s
    fmt.Println(d.Hours())      // 2.504166...
    fmt.Println(d.Minutes())    // 150.25
    fmt.Println(d.Seconds())    // 9015
    fmt.Println(d.Milliseconds()) // 9015000
}

time.Add et time.Sub

Ajoutez une durée à une heure, ou soustrayez deux heures pour obtenir une durée :

package main
import ("fmt"; "time")

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

    tomorrow := now.Add(24 * time.Hour)
    fmt.Println(tomorrow.Format("2006-01-02"))

    deadline := now.Add(30 * time.Minute)
    remaining := time.Until(deadline)  // alias for deadline.Sub(now)
    fmt.Printf("%.0f minutes left\n", remaining.Minutes())
}

Formatage et analyse des heures

Go utilise l'heure de référence Mon Jan 2 15:04:05 MST 2006 comme modèle de format (les valeurs 1 à 7 dans cet ordre) :

package main
import ("fmt"; "time")

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

    // Format
    fmt.Println(now.Format("2006-01-02"))          // 2024-01-15
    fmt.Println(now.Format("02/01/2006 15:04:05")) // 15/01/2024 10:30:00
    fmt.Println(now.Format(time.RFC3339))          // 2024-01-15T10:30:00Z
    fmt.Println(now.Format(time.Kitchen))          // 10:30AM
}

time.Parse — Analyse de chaînes

Analysez une chaîne pour obtenir un time.Time en utilisant le même modèle de référence :

package main
import ("fmt"; "time")

func main() {
    s := "2024-01-15"
    t, err := time.Parse("2006-01-02", s)
    if err != nil {
        fmt.Println("parse error:", err)
        return
    }
    fmt.Println(t.Year(), t.Month(), t.Day()) // 2024 January 15

    // Parse RFC3339 (ISO 8601):
    t2, _ := time.Parse(time.RFC3339, "2024-01-15T10:30:00Z")
    fmt.Println(t2)
}

time.Sleep et minuteries

Mettez l'exécution en pause avec time.Sleep ; créez des minuteries à déclenchement unique avec time.NewTimer :

package main
import ("fmt"; "time")

func main() {
    start := time.Now()
    time.Sleep(100 * time.Millisecond)
    fmt.Printf("slept for %v\n", time.Since(start))

    // One-shot timer
    timer := time.NewTimer(200 * time.Millisecond)
    <-timer.C  // blocks until timer fires
    fmt.Println("timer fired")
}

time.Ticker pour les événements répétés

time.NewTicker envoie une valeur sur son canal à intervalles réguliers :

package main
import ("fmt"; "time")

func main() {
    ticker := time.NewTicker(500 * time.Millisecond)
    defer ticker.Stop()  // always stop to avoid goroutine leak

    for i := 0; i < 3; i++ {
        t := <-ticker.C
        fmt.Println("tick at", t.Format("15:04:05.000"))
    }
}

time.Since et time.Until

Des raccourcis pratiques pour mesurer une durée écoulée et le temps restant avant un événement :

package main
import ("fmt"; "time")

func benchmark(fn func()) time.Duration {
    start := time.Now()
    fn()
    return time.Since(start)  // = time.Now().Sub(start)
}

func main() {
    d := benchmark(func() { time.Sleep(50 * time.Millisecond) })
    fmt.Printf("took %v\n", d)

    deadline := time.Now().Add(5 * time.Minute)
    fmt.Printf("%.0f minutes remaining\n", time.Until(deadline).Minutes())
}

Fuseaux horaires

Go gère les fuseaux horaires avec time.Location. Chargez les fuseaux avec time.LoadLocation :

package main
import ("fmt"; "time")

func main() {
    utc := time.Now().UTC()
    fmt.Println(utc)

    loc, err := time.LoadLocation("America/New_York")
    if err != nil { panic(err) }
    nyTime := utc.In(loc)
    fmt.Println(nyTime)

    // Compare times — always in UTC internally
    fmt.Println(utc.Equal(nyTime)) // true — same instant
}

time.Unix — Horodatages Unix

Convertissez entre time.Time et les horodatages Unix :

package main
import ("fmt"; "time")

func main() {
    now := time.Now()
    unix := now.Unix()            // seconds since epoch
    unixMilli := now.UnixMilli()  // milliseconds
    unixNano := now.UnixNano()    // nanoseconds

    fmt.Println(unix, unixMilli, unixNano)

    // Convert back:
    t := time.Unix(unix, 0)
    fmt.Println(t.Format(time.RFC3339))
}

Vérification rapide

Quelle heure de référence Go utilise-t-il comme modèle de format ?

Récapitulatif : paquet time

Résumé :

  • time.Now() — heure actuelle ; champs via .Year(), .Month(), etc.
  • time.Duration — nanosecondes ; utilisez time.Hour, time.Minute, etc.
  • t.Format(layout) / time.Parse(layout, s) — le format utilise l'heure de référence 2006-01-02 15:04:05
  • time.Since / time.Until pour mesurer le temps écoulé ou restant
  • time.NewTicker pour les événements périodiques — utilisez toujours defer Stop()

Questions Fréquemment Posées

La leçon « Les essentiels du package time » est-elle gratuite ?

Oui — le texte complet de « Les essentiels du package time » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Go Academy, passe à CoddyKit PRO. Le cours Go Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Les essentiels du package time » ?

Manipuler les heures, les durées et le formatage Tu pratiques Go Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Go Academy ?

Aucune expérience préalable n'est requise. Go Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.

Combien de temps prend la leçon « Les essentiels du package time » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Go Academy ?

Oui. Chaque leçon Go Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Packages fmt et strings
  2. strconv, math et sort
  3. Les essentiels du package time
  4. Packages os et filepath
← Retour à Go Academy