Go Academy · Leçon

Minuteries et tickers

Planifier et répéter des tâches

Minuteries et tickers 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.

Mettre en pause avec Sleep

L'outil de planification le plus simple est time.Sleep(d), qui met la goroutine actuelle en pause pendant une durée donnée.

package main

import (
    "fmt"
    "time"
)

func main() {
    fmt.Println("start")
    time.Sleep(10 * time.Millisecond)
    fmt.Println("done")
}

Qu'est-ce qu'un minuteur ?

Un time.Timer se déclenche une seule fois après un délai. À son expiration, il envoie l'instant présent sur son canal C.

package main

import (
    "fmt"
    "time"
)

func main() {
    t := time.NewTimer(10 * time.Millisecond)
    <-t.C
    fmt.Println("timer fired")
}

Raccourci time.After

time.After(d) renvoie un canal qui fournit une valeur après le délai. C'est un minuteur à usage unique pratique, sans variable.

package main

import (
    "fmt"
    "time"
)

func main() {
    <-time.After(10 * time.Millisecond)
    fmt.Println("elapsed")
}

Arrêter un minuteur

timer.Stop() annule un minuteur avant son déclenchement. Il renvoie true s'il a pu arrêter le minuteur à temps.

package main

import (
    "fmt"
    "time"
)

func main() {
    t := time.NewTimer(time.Hour)
    stopped := t.Stop()
    fmt.Println("stopped:", stopped)
}

Qu'est-ce qu'un déclencheur périodique ?

Un time.Ticker se déclenche de façon répétée à intervalles fixes, en envoyant une valeur sur son canal C à chaque déclenchement.

Utilisez-le pour les tâches périodiques, comme l'interrogation régulière ou les images d'une animation.

package main

import (
    "fmt"
    "time"
)

func main() {
    ticker := time.NewTicker(5 * time.Millisecond)
    <-ticker.C
    fmt.Println("tick")
    ticker.Stop()
}

Compter les déclenchements

Parcourez le canal du déclencheur périodique pour agir à chaque intervalle, puis arrêtez-le après un nombre suffisant de déclenchements.

package main

import (
    "fmt"
    "time"
)

func main() {
    ticker := time.NewTicker(5 * time.Millisecond)
    for i := 1; i <= 3; i++ {
        <-ticker.C
        fmt.Println("tick", i)
    }
    ticker.Stop()
}

Arrêtez toujours un déclencheur périodique

Contrairement aux minuteurs, un déclencheur périodique continue de fonctionner jusqu'à ce que vous appeliez Stop(). Oublier de l'arrêter entraîne une fuite de ressources.

package main

import (
    "fmt"
    "time"
)

func main() {
    ticker := time.NewTicker(5 * time.Millisecond)
    defer ticker.Stop()
    <-ticker.C
    fmt.Println("one tick, will stop on return")
}

La commodité de time.Tick

time.Tick(d) renvoie directement un canal de déclencheur périodique. C'est simple, mais il est impossible de l'arrêter : utilisez-le uniquement pendant toute la durée de vie du programme.

package main

import (
    "fmt"
    "time"
)

func main() {
    c := time.Tick(5 * time.Millisecond)
    <-c
    fmt.Println("ticked")
}

Délai avec select

Combinez un canal de travail avec time.After dans un select pour mettre en œuvre un délai d'expiration.

package main

import (
    "fmt"
    "time"
)

func main() {
    done := make(chan bool)
    go func() { done <- true }()
    select {
    case <-done:
        fmt.Println("work finished")
    case <-time.After(time.Second):
        fmt.Println("timed out")
    }
}

AfterFunc exécute une fonction de rappel

time.AfterFunc(d, f) exécute la fonction f dans sa propre goroutine après le délai, sans que vous ayez à lire un canal.

package main

import (
    "fmt"
    "time"
)

func main() {
    done := make(chan bool)
    time.AfterFunc(10*time.Millisecond, func() {
        fmt.Println("callback ran")
        done <- true
    })
    <-done
}

Minuteur ou déclencheur périodique

Faites votre choix selon que l'action doit se répéter ou non :

Minuteur : se déclenche une fois après un délai.
Déclencheur périodique : se déclenche à plusieurs reprises selon un intervalle.
Arrêtez les deux une fois le travail terminé pour libérer les ressources.

package main

import (
    "fmt"
    "time"
)

func main() {
    <-time.After(5 * time.Millisecond)
    fmt.Println("one-shot complete")
}

Vérification rapide

Quel type se déclenche à plusieurs reprises selon un intervalle fixe ?

Récapitulatif : minuteurs et déclencheurs périodiques

Vous avez appris à planifier des tâches :

Sleep met en pause ; Timer et time.After se déclenchent une fois.
Ticker et time.Tick se déclenchent à plusieurs reprises.
Utilisez Stop() pour libérer les ressources ; combinez-le avec select pour gérer les délais d'expiration.

package main

import (
    "fmt"
    "time"
)

func main() {
    ticker := time.NewTicker(5 * time.Millisecond)
    defer ticker.Stop()
    for i := 0; i < 2; i++ {
        <-ticker.C
        fmt.Println("beat")
    }
}

Questions Fréquemment Posées

La leçon « Minuteries et tickers » est-elle gratuite ?

Oui — le texte complet de « Minuteries et tickers » 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 « Minuteries et tickers » ?

Planifier et répéter des tâches 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 « Minuteries et tickers » ?

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