La fonction `init`

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

La fonction init est une fonction spéciale en Go qui s’exécute automatiquement lorsqu’un package est importé. Contrairement aux fonctions ordinaires, vous n’appelez pas directement init : Go l’exécute pour vous pendant le processus d’initialisation du package.

Voici comment définir une fonction init :

package mypackage

import "fmt"

func init() {
    fmt.Println("Package mypackage is being initialized!")
}

La fonction init possède quelques caractéristiques uniques : elle ne prend aucun paramètre, ne renvoie aucune valeur et s’exécute avant le démarrage de la fonction main. Cela la rend parfaite pour configurer l’état initial, enregistrer des composants ou effectuer des tâches de configuration ponctuelles dont votre package a besoin.

Lorsque vous importez un paquet qui contient une fonction init, vous verrez ses effets immédiatement, même si vous n'utilisez aucune des fonctions exportées du paquet. C'est pourquoi le modèle d'importation avec l'identificateur blanc que vous avez appris précédemment est si utile - il vous permet de déclencher l'initialisation d'un paquet sans utiliser directement son code.

Défi

Facile

Créez un système d'initialisation de packages qui montre comment les fonctions init s'exécutent automatiquement lorsque les packages sont importés. Vous allez construire un système de journalisation dans lequel différents packages s'initialisent eux-mêmes et suivent leur séquence de démarrage.

Vous recevrez deux entrées :

Une chaîne contenant les définitions des packages au format "package1:message1,package2:message2,package3:message3" (par exemple, "database:Database connection pool initialized,cache:Cache system ready,logger:Logging system started")
Une chaîne contenant les opérations du programme principal au format "operation1,operation2,operation3" (par exemple, "start_server,process_requests,shutdown")

Votre tâche consiste à :

Analyser la première entrée en la séparant sur les virgules afin d'obtenir les définitions individuelles des packages
Pour chaque définition de package, la séparer sur les deux-points afin d'obtenir le nom du package et le message d'initialisation
Créer une slice globale appelée initLog pour suivre les messages d'initialisation
Créer une fonction appelée logInit qui prend un nom de package et un message, puis ajoute le message formaté "[INIT] [package_name]: [message]" à la slice initLog
Simuler l'initialisation des packages en appelant logInit pour chaque package dans l'ordre où ils apparaissent dans l'entrée
Afficher l'en-tête de la séquence d'initialisation : "=== PACKAGE INITIALIZATION SEQUENCE ==="
Afficher chaque message d'initialisation de la slice initLog
Afficher l'en-tête du programme principal : "=== MAIN PROGRAM EXECUTION ==="
Afficher : "All packages initialized successfully"
Analyser la deuxième entrée en la séparant sur les virgules afin d'obtenir les opérations individuelles
Pour chaque opération du programme principal :

Afficher : "Executing: [operation]"
Ajouter un message au journal : "[MAIN] Operation: [operation]"

Afficher le résumé de l'exécution :

"=== EXECUTION SUMMARY ==="
"Packages initialized: [number_of_packages]"
"Main operations executed: [number_of_operations]"
"Total log entries: [total_number_of_log_entries]"

Afficher le journal complet :

"=== COMPLETE EXECUTION LOG ==="
Afficher chaque entrée du journal complet (les messages d'initialisation et les opérations principales)

Afficher le message final : "Program execution completed - all init functions ran before main"

Utilisez le package strings pour séparer les chaînes d'entrée et le package fmt pour produire une sortie formatée. Ce défi montre comment les fonctions init s'exécutent automatiquement lors de l'importation d'un package et s'exécutent toujours avant la fonction main, ce qui les rend idéales pour les tâches de configuration et d'initialisation des packages.

Essayez vous-même

package main

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

// Tranche globale pour suivre les messages d'initialisation
var initLog []string

func main() {
	reader := bufio.NewReader(os.Stdin)

	// Lire l'entrée (bufio gère correctement les lignes avec des espaces)
	packageDefs, _ := reader.ReadString('\n')
	packageDefs = strings.TrimRight(packageDefs, "\r\n")

	mainOps, _ := reader.ReadString('\n')
	mainOps = strings.TrimRight(mainOps, "\r\n")

	// TODO: Écrivez votre code ci-dessous
	// 1. Analyser packageDefs en divisant par "," pour obtenir les entrées de paquets individuelles
	// 2. Pour chaque entrée, diviser par ":" (max 2 parties) pour obtenir packageName et message
	// 3. Créer une fonction logInit(packageName, message string) qui ajoute
	//    "[INIT] [packageName]: message" à la tranche globale initLog
	// 4. Afficher l'en-tête de la séquence d'initialisation et toutes les entrées du journal d'initialisation
	// 5. Afficher l'en-tête d'exécution principale et traiter chaque opération de mainOps
	//    - Imprimer "Executing: <op>" pour chaque opération
	//    - Ajouter "[MAIN] Operation: <op>" à initLog
	// 6. Afficher le résumé de l'exécution (nombre de paquets, nombre d'opérations, total des entrées du journal)
	// 7. Afficher le journal complet et le message final d'achèvement

}

Testez-vous

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

Toutes les leçons de Logique & Flux

Entraînez-vous par vous-même : Compilateur Go en ligne