Parsing de chaînes de temps

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

Parfois, vous recevrez des informations de date et d'heure sous forme de chaînes de caractères qui doivent être converties en objets time.Time pour être traitées. Go fournit la fonction time.Parse pour gérer cette conversion.

La fonction time.Parse fonctionne comme l'inverse du formatage - elle prend une chaîne de mise en page (layout) et une chaîne de temps, puis renvoie un objet time.Time :

dateString := "2023-10-26"
parsedTime, err := time.Parse("2006-01-02", dateString)
if err != nil {
    fmt.Println("Error parsing time:", err)
} else {
    fmt.Println(parsedTime)
}

Tout comme pour le formatage, vous utilisez les mêmes composants de date de référence dans votre chaîne de mise en page. La mise en page "2006-01-02" indique à Go d'attendre la chaîne d'entrée au format YYYY-MM-DD. La mise en page doit correspondre exactement au format de votre chaîne d'entrée.

N'oubliez pas que time.Parse retourne deux valeurs : l'objet time.Time analysé et une erreur. Vérifiez toujours l'erreur pour vous assurer que l'analyse a réussi, car des chaînes de date invalides ou des formats (layouts) non correspondants entraîneront l'échec de l'analyse.

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 analyseur de fichiers journaux qui convertit des chaînes d'horodatage de divers formats en objets time.Time pour analyse. Ce défi testera votre capacité à utiliser time.Parse avec différents modèles de mise en forme (layouts) pour gérer plusieurs formats de date et d'heure couramment trouvés dans les journaux système.

Note importante : Étant donné que les messages de journal et les modèles de mise en forme peuvent contenir des espaces, vous devrez utiliser bufio.Scanner pour lire des lignes entières d'entrée. La fonction fmt.Scanln s'arrête de lire au premier espace, ce qui briserait les entrées de journal et les mises en forme contenant des espaces. Utilisez bufio.NewScanner(os.Stdin) et appelez scanner.Scan() suivi de scanner.Text() pour lire des lignes complètes.

Vous recevrez deux entrées :

Une chaîne contenant des entrées de journal au format "timestamp1:message1,timestamp2:message2,timestamp3:message3" (par exemple, "2023-10-26:System startup,2023/12/25:Holiday shutdown,Jan 15 2024:Maintenance window")
Une chaîne contenant des modèles de mise en forme séparés par des virgules au format "layout1,layout2,layout3" (par exemple, "2006-01-02,2006/01/02,Jan 2 2006")

Votre tâche consiste à :

Utiliser bufio.Scanner pour lire correctement les lignes d'entrée afin de gérer les espaces dans les messages de journal et les modèles de mise en forme
Analyser la première entrée en la découpant au niveau des virgules pour obtenir les entrées de journal individuelles
Pour chaque entrée de journal, découper au niveau des deux-points pour extraire la chaîne d'horodatage et le message
Analyser la deuxième entrée en la découpant au niveau des virgules pour obtenir les modèles de mise en forme
Afficher l'en-tête de l'application : "=== LOG TIMESTAMP PARSER ==="
Afficher le statut du traitement : "Processing log entries with multiple timestamp formats..."
Pour chaque entrée de journal, tenter d'analyser l'horodatage en utilisant chaque modèle de mise en forme jusqu'à ce qu'un réussisse :
- Essayer chaque modèle de mise en forme avec time.Parse jusqu'à ce que l'analyse réussisse (pas d'erreur)
- En cas de succès, afficher : "Parsed: [timestamp_string] -> [parsed_time_object] (using layout: [successful_layout])"
- Afficher également : " Message: [log_message]"
- Si aucun modèle ne fonctionne pour un horodatage, afficher : "Failed to parse: [timestamp_string] - no matching layout found"
Après avoir traité toutes les entrées, afficher les statistiques d'analyse :
- "=== PARSING RESULTS ==="
- "Total log entries processed: [number_of_entries]"
- "Successfully parsed timestamps: [number_of_successful_parses]"
- "Failed parsing attempts: [number_of_failed_parses]"
Afficher les statistiques d'utilisation des modèles :
- "Layout pattern usage:"
- Pour chaque modèle de mise en forme : " [layout_pattern]: [number_of_times_used] times"
Si des horodatages ont été analysés avec succès, afficher l'analyse chronologique :
- "=== CHRONOLOGICAL ANALYSIS ==="
- "Earliest timestamp: [earliest_parsed_time]"
- "Latest timestamp: [latest_parsed_time]"
- "Time span covered: [time_difference_description]"
Afficher le message de fin : "Log parsing completed - timestamps converted to time objects"

Utilisez le package time pour les opérations d'analyse, le package strings pour découper les chaînes d'entrée, les packages bufio et os pour une gestion appropriée des entrées, et le package fmt pour la sortie formatée. N'oubliez pas que time.Parse renvoie à la fois un objet time.Time et une erreur - vous devez vérifier l'erreur pour déterminer si l'analyse a réussi. Lorsqu'une analyse échoue avec un modèle, essayez le modèle suivant jusqu'à ce que vous en trouviez un qui fonctionne ou que vous ayez épuisé toutes les options. Ce défi démontre comment gérer plusieurs formats d'horodatage dans des scénarios réels de traitement de journaux.

Aide-mémoire

Utilisez time.Parse pour convertir des chaînes de date/heure en objets time.Time :

dateString := "2023-10-26"
parsedTime, err := time.Parse("2006-01-02", dateString)
if err != nil {
    fmt.Println("Error parsing time:", err)
} else {
    fmt.Println(parsedTime)
}

La chaîne de mise en page (layout) doit correspondre au format exact de votre chaîne d'entrée en utilisant les composants de date de référence de Go. time.Parse renvoie à la fois un objet time.Time et une erreur - vérifiez toujours l'erreur pour vous assurer que l'analyse a réussi.

Essayez vous-même

package main

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

func main() {
	// Créer un scanner pour lire les lignes d'entrée
	scanner := bufio.NewScanner(os.Stdin)
	
	// Lire les entrées de journal
	scanner.Scan()
	logEntries := scanner.Text()
	
	// Lire les modèles de mise en page
	scanner.Scan()
	layoutPatterns := scanner.Text()
	
	// Analyser les entrées
	entries := strings.Split(logEntries, ",")
	layouts := strings.Split(layoutPatterns, ",")
	
	// Initialiser les compteurs pour les statistiques
	totalEntries := len(entries)
	successfulParses := 0
	failedParses := 0
	layoutUsage := make(map[string]int)
	var parsedTimes []time.Time
	
	// TODO: Écrivez votre code ci-dessous
	// 1. Afficher l'en-tête de l'application
	// 2. Afficher le statut du traitement
	// 3. Traiter chaque entrée de journal :
	//    - Diviser l'entrée sur ":" pour obtenir l'horodatage et le message
	//    - Essayer chaque modèle de mise en page jusqu'à ce qu'un fonctionne
	//    - Afficher les résultats de l'analyse
	//    - Mettre à jour les statistiques
	// 4. Afficher les statistiques d'analyse
	// 5. Afficher les statistiques d'utilisation des modèles
	// 6. Si des horodatages ont été analysés, afficher l'analyse chronologique
	// 7. Afficher le message de fin
	
}

Testez-vous

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