Envelopper des erreurs avec `%w`

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

Lorsque des erreurs surviennent dans votre application, elles ont souvent besoin de contexte supplémentaire à mesure qu'elles remontent à travers les différentes couches de votre code. Go fournit un mécanisme puissant pour cela via l'emballage d'erreurs (error wrapping) en utilisant le verbe de formatage %w avec fmt.Errorf.

L'enveloppement d'erreurs (error wrapping) vous permet d'ajouter des informations contextuelles à une erreur existante tout en préservant l'erreur d'origine sous-jacente. Cela crée une chaîne d'erreurs qui conserve l'historique complet de ce qui s'est mal passé :

originalErr := errors.New("file not found")
wrappedErr := fmt.Errorf("failed to load config: %w", originalErr)

Le verbe %w est spécial - il indique à fmt.Errorf d'envelopper l'erreur plutôt que de simplement la convertir en une chaîne de caractères. Cela préserve l'erreur d'origine afin qu'elle puisse être examinée plus tard à l'aide de fonctions telles que errors.Is et errors.As.

Ce modèle est particulièrement précieux dans les applications de plus grande envergure où une erreur peut passer par plusieurs fonctions, chacune ajoutant son propre contexte. Par exemple, une erreur de connexion à la base de données pourrait être enveloppée avec "failed to connect to database", puis enveloppée à nouveau avec "unable to start server", créant ainsi une trace claire de ce qui s'est passé et où.

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

Construisez un système de traitement de fichiers qui enveloppe les erreurs avec des informations contextuelles au fur et à mesure qu'elles se propagent à travers les différentes couches de votre application. Ce défi démontre comment utiliser le verbe de formatage %w avec fmt.Errorf pour créer des chaînes d'erreurs qui préservent l'erreur d'origine tout en ajoutant un contexte significatif.

Vous recevrez deux entrées :

Une chaîne contenant les détails de l'opération sur le fichier au format "filename,operation,status" (par exemple, "config.json,read,permission_denied")
Une chaîne contenant le contexte du système au format "service_name,component" (par exemple, "UserService,ConfigLoader")

Votre tâche consiste à :

Analyser la première entrée en la divisant par les virgules pour obtenir le nom du fichier (filename), l'opération (operation) et le statut (status)
Analyser la deuxième entrée en la divisant par les virgules pour obtenir le nom du service (service name) et le composant (component)
Créer une erreur d'origine basée sur le statut en utilisant errors.New() :
- Si le statut est "permission_denied" : "permission denied"
- Si le statut est "not_found" : "file not found"
- Si le statut est "corrupted" : "file corrupted"
- Pour tout autre statut : "unknown error"
Créer une erreur enveloppée au niveau du fichier en utilisant fmt.Errorf avec %w : "failed to [operation] file [filename]: %w"
Créer une erreur enveloppée au niveau du composant : "[component] error: %w"
Créer une erreur enveloppée au niveau du service : "[service_name] operation failed: %w"
Afficher la chaîne d'erreurs en imprimant chaque niveau :
- "Original error: [original_error_message]"
- "File level: [file_level_error_message]"
- "Component level: [component_level_error_message]"
- "Service level: [service_level_error_message]"
Afficher un résumé de la chaîne d'erreurs :
- "Error Chain Summary:"
- "File: [filename]"
- "Operation: [operation]"
- "Component: [component]"
- "Service: [service_name]"
- "Root cause: [original_error_message]"

Utilisez le package strings pour diviser les chaînes d'entrée par les virgules, le package errors pour créer l'erreur d'origine, et le package fmt pour créer les erreurs enveloppées. Ce défi démontre comment l'enveloppement d'erreurs avec %w crée une trace claire du contexte à mesure que les erreurs traversent les différentes couches de votre application, rendant le débogage beaucoup plus efficace.

Aide-mémoire

L'emballage d'erreurs (error wrapping) vous permet d'ajouter des informations contextuelles à une erreur existante tout en préservant l'erreur originale. Utilisez le verbe de formatage %w avec fmt.Errorf :

originalErr := errors.New("file not found")
wrappedErr := fmt.Errorf("failed to load config: %w", originalErr)

Le verbe %w préserve l'erreur originale afin qu'elle puisse être examinée plus tard à l'aide de fonctions telles que errors.Is et errors.As. Cela crée une chaîne d'erreurs qui conserve l'historique complet de ce qui s'est mal passé, ce qui est précieux lorsque les erreurs passent par plusieurs fonctions dans des applications plus vastes.

Essayez vous-même

package main

import (
	"errors"
	"fmt"
	"strings"
)

func main() {
	// Lire l'entrée
	var fileDetails string
	var systemContext string
	fmt.Scanln(&fileDetails)
	fmt.Scanln(&systemContext)
	
	// Analyser les entrées
	fileInfo := strings.Split(fileDetails, ",")
	filename := fileInfo[0]
	operation := fileInfo[1]
	status := fileInfo[2]
	
	contextInfo := strings.Split(systemContext, ",")
	serviceName := contextInfo[0]
	component := contextInfo[1]
	
	// TODO: Écrivez votre code ci-dessous
	// Créer l'erreur d'origine basée sur le statut
	// Créer l'erreur encapsulée au niveau du fichier
	// Créer l'erreur encapsulée au niveau du composant
	// Créer l'erreur encapsulée au niveau du service
	// Afficher chaque niveau d'erreur 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.