Golang détecte les erreurs globales

Golang est un langage de programmation moderne conçu pour être une solution efficace permettant aux programmeurs de gérer et d'écrire facilement des programmes à grande échelle. Golang est bon en programmation simultanée et est largement utilisé dans certaines applications à haute disponibilité. Cependant, lors du développement d’une application, nous devons toujours prêter attention à la gestion des erreurs, car ne pas les gérer peut entraîner un comportement instable du système. Dans cet article, nous verrons comment détecter les erreurs globales dans Golang.

La gestion des erreurs est une partie importante de l'écriture d'applications de haute qualité. Dans Golang, il existe deux types d'erreurs :

L'un est un type d'erreur qui peut être défini sous la forme générale d'une signature de fonction. Ces erreurs sont des erreurs que les fonctions peuvent générer.

L'autre concerne les erreurs d'exécution, telles qu'une référence de pointeur nul ou une boucle infinie, etc.

Quel que soit le type d'erreur, vous devez être très prudent lors de l'écriture de programmes. Une méthode générale de gestion des erreurs consiste à utiliser un ErrorHandler global. Un ErrorHandler global peut détecter les erreurs à l'échelle du programme. C'est un très bon choix car il peut gérer toutes les erreurs en un seul endroit.

Tout d'abord, nous devons définir un ErrorHandler global :

func globalErrorHandler(err error) {
    fmt.Printf("Recovered from panic, error message: %v", err)
}

Ensuite, nous pouvons appeler la fonction de récupération dans la fonction principale, qui enregistre le ErrorHandler global :

func main() {
    defer func() {
        if err := recover(); err != nil {
            globalErrorHandler(fmt.Errorf("%v", err))
        }
    }()
    // your code here
}

Ici, nous utilisons le mot-clé defer pour nous assurer que notre ErrorHandler appelé avant la fonction se termine. Cette approche garantit que même si une erreur est générée par la fonction principale ou tout autre code, nous pouvons la détecter et la gérer à temps.

Après avoir enregistré ErrorHandler, nous pouvons utiliser le mécanisme de panique de Golang pour simuler des erreurs. Si panic est appelé, le globalErrorHandler que nous avons défini sera automatiquement appelé. Nous pouvons ensuite imprimer les détails de l'erreur dans ErrorHandler ou l'envoyer au système de journalisation pour un débogage ultérieur.

Pour tester le ErrorHandler, nous pouvons écrire une fonction simple :

func someFunc() {
    a := []int{1, 2, 3}
    fmt.Println(a[5])
}

Lorsque nous utilisons un index en dehors de la plage de tranches dans la fonction, une panique se produit. À ce stade, nous pouvons tester le ErrorHandler pour nous assurer qu’il détecte correctement les erreurs.

Enfin, nous intégrons cela dans un exemple de programme :

package main

import (
    "fmt"
)

func globalErrorHandler(err error) {
    fmt.Printf("Recovered from panic, error message: %v", err)
}

func someFunc() {
    a := []int{1, 2, 3}
    fmt.Println(a[5])
}

func main() {
    defer func() {
        if err := recover(); err != nil {
            globalErrorHandler(fmt.Errorf("%v", err))
        }
    }()
    someFunc()
}

Nous pouvons maintenant appeler d'autres fonctions dans la fonction principale et y déclencher une erreur en essayant d'utiliser un index invalide. À ce stade, le ErrorHandler global que nous avons défini capturera les informations d'erreur et les imprimera.

En bref, Golang est un langage de programmation efficace et ses capacités de programmation simultanée sont excellentes. Mais que ce soit dans la programmation simultanée ou dans d’autres scénarios d’application, nous devons gérer les erreurs avec précaution. Lors de la gestion des erreurs, l'utilisation d'un ErrorHandler global est une très bonne solution car elle garantit que toutes les erreurs que nous détectons dans notre application sont traitées de manière centralisée.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!