Sleep et Tickers

Fait partie de la section Logique & Flux du Journey GO de Coddy — leçon 64 sur 68.

Parfois, vous devez contrôler le timing de l'exécution de votre programme. Go fournit deux fonctions essentielles dans le package time pour cela : time.Sleep pour mettre l'exécution en pause et time.NewTicker pour effectuer des actions à intervalles réguliers.

La fonction time.Sleep met votre programme en pause pendant une durée spécifiée. Elle prend un time.Duration comme paramètre et bloque l'exécution jusqu'à ce que ce temps soit écoulé :

fmt.Println("Starting...")
time.Sleep(2 * time.Second)
fmt.Println("Two seconds have passed!")

Pour les actions répétées à intervalles réguliers, time.NewTicker crée un ticker qui envoie des valeurs sur un canal à des intervalles spécifiés. Ceci est utile pour les tâches qui doivent s'exécuter périodiquement :

ticker := time.NewTicker(1 * time.Second)
for i := 0; i < 3; i++ {
    <-ticker.C // Wait for the next tick
    fmt.Println("Tick", i+1)
}

Ces fonctions de temporisation sont essentielles pour créer des délais, implémenter des timeouts et planifier des opérations récurrentes dans vos programmes Go.

Testez-vous

Cette leçon comprend un petit quiz. Commencez la leçon pour y répondre et suivre votre progression.

Testez-vous

Cette leçon comprend un petit quiz. Commencez la leçon pour y répondre et suivre votre progression.

Testez-vous

Cette leçon comprend un petit quiz. Commencez la leçon pour y répondre et suivre votre progression.

Défi

Facile

Créez un minuteur de session de méditation qui utilise time.Sleep pour créer des pauses entre les instructions guidées et démontre le contrôle de base du timing dans les programmes Go.

Vous recevrez deux entrées :

Une chaîne contenant les étapes de méditation au format "step1:duration,step2:duration,step3:duration" (par exemple, "Breathe in:3,Hold:2,Breathe out:4")
Une chaîne contenant le nombre de cycles à répéter (par exemple, "5")

Votre tâche consiste à :

Analyser la première entrée en la divisant par les virgules pour obtenir les étapes de méditation individuelles
Pour chaque étape, diviser par les deux-points pour extraire l'instruction et la durée (en secondes)
Convertir les chaînes de durée en entiers à l'aide du package strconv
Convertir la deuxième entrée en entier pour obtenir le nombre de cycles
Afficher l'en-tête de la session : "=== MEDITATION TIMER ==="
Afficher la configuration de la session : "Starting meditation session with [number_of_cycles] cycles"
Pour chaque cycle (en commençant par le cycle 1) :
- Afficher : "--- Cycle [cycle_number] ---"
- Pour chaque étape de méditation :
  - Afficher : "[instruction]..."
  - Utiliser time.Sleep pour faire une pause pendant la durée spécifiée (convertir les secondes en time.Duration en multipliant par time.Second)
  - Après la pause, afficher : "[instruction] complete ([duration] seconds)"
- Après avoir terminé toutes les étapes d'un cycle, afficher : "Cycle [cycle_number] finished"
Une fois tous les cycles terminés, afficher le résumé de la session :
- "=== SESSION COMPLETE ==="
- "Total cycles completed: [number_of_cycles]"
- "Steps per cycle: [number_of_steps]"
- "Total meditation time: [total_seconds] seconds" (somme de toutes les durées d'étape multipliée par le nombre de cycles)
Afficher le message de fin : "Meditation session finished - well done!"

Utilisez le package time pour les opérations de pause, le package strings pour diviser les chaînes d'entrée, le package strconv pour convertir les chaînes en entiers, et le package fmt pour la sortie. N'oubliez pas que time.Sleep prend un paramètre time.Duration, vous devez donc multiplier vos secondes entières par time.Second pour créer la valeur de durée appropriée. Ce défi démontre comment utiliser time.Sleep pour créer des pauses chronométrées dans l'exécution d'un programme pour des applications pratiques comme la méditation guidée ou les minuteurs d'exercice.

Aide-mémoire

Utilisez time.Sleep pour mettre en pause l'exécution du programme pendant une durée spécifiée :

time.Sleep(2 * time.Second)

Utilisez time.NewTicker pour effectuer des actions à intervalles réguliers :

ticker := time.NewTicker(1 * time.Second)
for i := 0; i < 3; i++ {
    <-ticker.C // Attendre le prochain tick
    fmt.Println("Tick", i+1)
}

Les deux fonctions utilisent des valeurs time.Duration. Convertissez les entiers en durée en les multipliant par time.Second.

Essayez vous-même

package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
	"strings"
	"time"
)

func main() {
	// Lire l'entrée en utilisant bufio.Scanner pour gérer correctement les espaces
	scanner := bufio.NewScanner(os.Stdin)
	
	scanner.Scan()
	stepsInput := scanner.Text()
	
	scanner.Scan()
	cyclesInput := scanner.Text()
	
	// Analyser les étapes et les cycles de méditation
	steps := strings.Split(stepsInput, ",")
	cycles, _ := strconv.Atoi(cyclesInput)
	
	// TODO : Écrivez votre code ci-dessous
	// Analyser chaque étape pour extraire l'instruction et la durée
	// N'oubliez pas de vérifier si la tranche (slice) "parts" a suffisamment d'éléments avant d'y accéder
	// Afficher l'en-tête de la session et la configuration
	// Parcourir les cycles et les étapes
	// Utiliser time.Sleep pour les pauses (envisagez d'utiliser des millisecondes pour les tests)
	// Afficher les messages de fin et le résumé
	
}

Testez-vous

Cette leçon comprend un petit quiz. Commencez la leçon pour y répondre et suivre votre progression.