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 rythme d’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. Cela 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, implémenter des timeouts 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 qui montre le contrôle basique du temps 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 afin d'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 représentant les durées en entiers à l'aide du package strconv
Convertir la deuxième entrée en entier afin d'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 de la durée indiquée (convertir les secondes en time.Duration en les 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 séance :
- "=== SESSION COMPLETE ==="
- "Total cycles completed: [number_of_cycles]"
- "Steps per cycle: [number_of_steps]"
- "Total meditation time: [total_seconds] seconds" (la somme de toutes les durées des é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 l'affichage. N'oubliez pas que time.Sleep accepte un paramètre de type time.Duration ; vous devez donc multiplier vos secondes entières par time.Second afin de créer une valeur de durée appropriée. Ce défi montre comment utiliser time.Sleep pour créer des pauses temporisées lors de l'exécution d'un programme, dans des applications pratiques telles que les minuteurs de méditation guidée ou d'exercice.

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é
	
}