Sleep et Tickers

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

Parfois, tu dois contrôler le rythme d’exécution de ton 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 une time.Duration en paramètre et bloque l’exécution jusqu’à ce que cette durée soit écoulée :

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. C’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 // Attendre le prochain tick
    fmt.Println("Tick", i+1)
}

Ces fonctions de temporisation sont essentielles pour créer des délais, mettre en œuvre des délais d’attente et planifier des opérations récurrentes dans vos programmes Go.

Défi

Facile

Créez un minuteur de séance de méditation qui utilise time.Sleep pour créer des pauses entre les instructions guidées et présenter le contrôle de base du minutage 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 séparant sur les virgules pour obtenir les différentes étapes de méditation
Pour chaque étape, la séparer sur les deux-points afin d’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 séance : "=== MEDITATION TIMER ==="
Afficher la configuration de la séance : "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 (multiplier la durée par time.Millisecond, comme dans time.Duration(duration) * time.Millisecond, afin que les vérifications se terminent rapidement ; la sortie indique toujours les secondes)
  - 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écapitulatif de la séance :
- "=== SESSION COMPLETE ==="
- "Total cycles completed: [number_of_cycles]"
- "Steps per cycle: [number_of_steps]"
- "Total meditation time: [total_seconds] seconds" (somme des durées de toutes les étapes 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 séparer 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 : convertissez donc d’abord l’entier : time.Duration(duration) * time.Millisecond. Un vrai minuteur utiliserait time.Second, mais des pauses de plusieurs secondes entraîneraient l’expiration du délai des vérifications. Ce défi montre comment utiliser time.Sleep pour créer des pauses minutées pendant l’exécution d’un programme, dans des applications pratiques comme les séances de méditation guidée ou les minuteurs d’exercice.

Essayez vous-même

package main

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

func main() {
	// Lisez l’entrée avec bufio.Scanner pour gérer correctement les espaces
	scanner := bufio.NewScanner(os.Stdin)
	
	scanner.Scan()
	stepsInput := scanner.Text()
	
	scanner.Scan()
	cyclesInput := scanner.Text()
	
	// Analysez les étapes et les cycles de méditation
	steps := strings.Split(stepsInput, ",")
	cycles, _ := strconv.Atoi(cyclesInput)
	
	// TODO: Écrivez votre code ci-dessous
	// Analysez chaque étape pour en extraire l’instruction et la durée
	// Pensez à vérifier que la tranche parts contient suffisamment d’éléments avant d’y accéder
	// Affichez l’en-tête de la séance et les informations de préparation
	// Parcourez les cycles et les étapes à l’aide de boucles
	// Utilisez time.Sleep pour les pauses : time.Duration(duration) * time.Millisecond
	// Affichez les messages de fin et le récapitulatif
	
}