Go Academy · Leçon

Planification temporelle

Exécuter des tâches périodiques

Planification temporelle est une leçon Go Academy gratuite sur CoddyKit. Ceci est la leçon 1 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.

Exécuter des tâches selon un calendrier

De nombreux systèmes ont besoin de tâches périodiques : nettoyer les fichiers temporaires chaque nuit, envoyer un courriel récapitulatif chaque matin ou interroger une API toutes les minutes. Cette leçon présente la planification fondée sur le temps en Go à l'aide de la bibliothèque standard.

Le package time

Le package time de Go constitue la base. Ses principaux outils sont les suivants :

time.Sleep met une gouroutine en pause
time.After renvoie un canal qui se déclenche une seule fois
time.Ticker se déclenche de façon répétée
time.Timer se déclenche une fois après un délai

Une boucle naïve

Le planificateur le plus simple : effectuer la tâche, attendre, puis recommencer.

package main

import (
    "fmt"
    "time"
)

func main() {
    for i := 0; i < 3; i++ {
        fmt.Println("tick", i)
        time.Sleep(10 * time.Millisecond)
    }
}

Pourquoi Sleep dérive

Une boucle avec attente dérive : si la tâche prend 200 ms et que vous attendez 1 s, votre intervalle réel est de 1,2 s, et l'écart s'accumule. Pour obtenir des intervalles précis, utilisez un Ticker, présenté dans une leçon ultérieure.

time.After pour les délais ponctuels

time.After(d) renvoie un canal qui reçoit une valeur une seule fois après la durée d. C'est utile dans une instruction select pour gérer les délais d'expiration.

select {
case <-time.After(2 * time.Second):
    fmt.Println("2s elapsed")
}

time.Timer

Un Timer se déclenche une fois et peut être arrêté ou réinitialisé, contrairement à time.After, que vous ne pouvez pas annuler.

t := time.NewTimer(5 * time.Second)
defer t.Stop()
<-t.C
fmt.Println("fired")

Planifier une tâche à une heure précise

Pour exécuter une tâche, par exemple à 3 AM, calculez la durée jusqu'à ce moment, puis utilisez une attente ou un minuteur pour cette durée avant de reprogrammer la tâche pour le lendemain.

now := time.Now()
next := time.Date(now.Year(), now.Month(), now.Day(), 3, 0, 0, 0, now.Location())
if next.Before(now) {
    next = next.Add(24 * time.Hour)
}
fmt.Println("sleep for", time.Until(next))

Les durées sont typées

time.Duration est un entier int64 exprimé en nanosecondes, avec des constantes pratiques : time.Second, time.Minute et time.Hour. Multipliez-les pour obtenir des intervalles lisibles.

every := 30 * time.Minute
fmt.Println(every)

Horloge monotone et horloge civile

Le time.Now de Go inclut une mesure monotone utilisée pour mesurer le temps écoulé, insensible aux ajustements de l'horloge. Utilisez time.Since pour les durées, plutôt qu'une soustraction entre deux heures civiles.

start := time.Now()
// ... work ...
fmt.Println("took", time.Since(start))

Quand utiliser une bibliothèque

Pour les calendriers complexes, comme « chaque jour ouvré à 9 h 15 », calculer soi-même les horaires est source d'erreurs. La bibliothèque robfig/cron, présentée ensuite, analyse les expressions Cron à votre place.

Exécutable : calculer la prochaine exécution

Ce programme autonome calcule le temps restant avant le début de la prochaine minute en utilisant uniquement le package time.

package main

import (
    "fmt"
    "time"
)

func main() {
    now := time.Date(2026, 1, 1, 10, 30, 45, 0, time.UTC)
    nextMinute := now.Truncate(time.Minute).Add(time.Minute)
    fmt.Println("now:", now.Format("15:04:05"))
    fmt.Println("next run:", nextMinute.Format("15:04:05"))
    fmt.Println("wait:", nextMinute.Sub(now))
}

Vérification rapide

Vérifiez votre compréhension de la planification fondée sur le temps.

Récapitulatif

Vous avez découvert les bases de la planification fondée sur le temps :

Le package time fournit Sleep, After, Timer et Ticker
Les boucles avec Sleep dérivent ; les déclencheurs périodiques restent synchronisés
Calculez les durées jusqu'à une heure cible avec time.Until
Utilisez time.Since et l'horloge monotone pour mesurer le temps écoulé

Questions Fréquemment Posées

La leçon « Planification temporelle » est-elle gratuite ?

Oui — le texte complet de « Planification temporelle » 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 « Planification temporelle » ?

Exécuter des tâches périodiques 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 1 sur 4.

Combien de temps prend la leçon « Planification temporelle » ?

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

← Retour à Go Academy