golang détermine le type d'erreur

Golang est un langage de programmation simple et efficace. Il dispose d'un système de types puissant et de bibliothèques riches, offrant aux développeurs une grande commodité. La gestion des erreurs est une tâche très importante dans le langage Go. Lorsqu'une erreur se produit pendant l'exécution du programme, nous devons être capables de trouver l'erreur rapidement et précisément et de la gérer. Afin d'atteindre cet objectif, nous devons savoir comment déterminer le type d'erreur, découvrons-le ensemble.

1. Quels sont les types d'erreurs ?

Le type d'erreur fait référence au type d'objet d'erreur dans Golang. Dans le langage Go, le type d'erreur est un type d'interface qui définit une méthode nommée "Error()", qui renvoie une chaîne représentant les informations d'erreur actuelles. Dans le code Golang, la fonction New() du package error est généralement utilisée pour créer un nouvel objet d'erreur. L'exemple de code est le suivant :

import "errors"
err := errors.New("this is an error")

2. Comment déterminer le type d'erreur ?

La façon de déterminer le type d'erreur dans Golang est très simple. Nous avons uniquement besoin d'utiliser l'assertion de type pour convertir l'objet d'erreur. Dans l'assertion de type, nous pouvons affirmer un type d'interface à un autre type d'interface, comme l'affirmation d'un objet d'erreur à un type d'erreur personnalisé. L'exemple de code est le suivant :

type MyError struct {
    message string
}

func (e *MyError) Error() string {
    return e.message
}

func doSomething() error {
    return &MyError{message: "This is a custom error"}
}

func main() {
    err := doSomething()
    if e, ok := err.(*MyError); ok {
        // 错误类型是 MyError
        fmt.Println(e.message)
    } else if err != nil {
        // 其他类型的错误
        fmt.Println("error:", err)
    } else {
        // 没有发生错误
        fmt.Println("no error")
    }
}

Dans l'exemple de code ci-dessus, nous définissons un type d'erreur personnalisé MyError, qui implémente la méthode Error(). Ensuite, nous renvoyons une instance de MyError dans la fonction doSomething(). Dans la fonction main(), nous convertissons cet objet d'erreur en type MyError via l'assertion de type. Si la conversion réussit, cela signifie que le type d'erreur est MyError et nous pouvons le gérer si nécessaire. Si la conversion échoue, l'objet d'erreur est un autre type d'erreur.

Notez que la syntaxe de l'assertion de type ici est "e, ok := err.(*MyError)", où ok indique si l'assertion de type est réussie. Si la conversion de err en type MyError réussit, alors ok sera vrai, sinon ok sera faux.

En plus des assertions de type, vous pouvez également utiliser les fonctions Is() et As() fournies par le package d'erreurs pour déterminer et convertir les types d'erreurs. L'utilisation spécifique est la suivante :

if errors.Is(err, io.EOF) {
    // 错误类型是 io.EOF
}

var target *MyError
if errors.As(err, &target) {
    // 错误类型是 *MyError
}

3. Comment gérer les types d'erreurs

Après avoir déterminé le type spécifique d'une erreur, nous pouvons adopter différentes méthodes de traitement selon les besoins. Les méthodes courantes de gestion des erreurs incluent :

3.1 Imprimer le message d'erreur

S'il ne s'agit que d'un petit problème, nous pouvons imprimer le message d'erreur directement, par exemple :

func doSomething() error {
    if err := someFunc(); err != nil {
        return fmt.Errorf("调用 someFunc() 错误：%v", err)
    }
    return nil
}

Dans le code ci-dessus, lorsque la fonction someFunc() renvoie une erreur , nous utilisons fmt La fonction .Errorf() imprime le message d'erreur et le renvoie à l'appelant.

3.2 Renvoyer l'erreur directement

Si l'erreur est grave, nous pouvons renvoyer l'erreur directement et laisser l'appelant de niveau supérieur gérer l'erreur, par exemple :

func doSomething() error {
    if err := someFunc(); err != nil {
        return err
    }
    return nil
}

Dans le code ci-dessus, lorsque la fonction someFunc() renvoie un erreur, nous revenons directement Pour cette erreur, laissez l'appelant de niveau supérieur déterminer le type d'erreur et le gérer.

3.3 Reportez-vous aux méthodes de traitement de la bibliothèque standard

Pour certains types d'erreurs courants, la bibliothèque standard fournit certaines méthodes de traitement pour notre référence. Par exemple, lorsque l'ouverture d'un fichier échoue, la bibliothèque standard renverra une erreur de type os.PathError. À ce stade, nous pouvons nous référer à l'approche de la bibliothèque standard pour la gérer :

func doSomething(filename string) error {
    f, err := os.Open(filename)
    if err != nil {
        if os.IsNotExist(err) {
            return fmt.Errorf("文件 %s 不存在", filename)
        } else if os.IsPermission(err) {
            return fmt.Errorf("无权限访问文件 %s", filename)
        }
        return err
    }
    defer f.Close()
    // do something
    return nil
}

Dans le code ci-dessus, nous essayons d'abord d'ouvrir. un fichier, et lorsque l'ouverture échoue Quand, nous utilisons les fonctions os.IsNotExist() et os.IsPermission() pour déterminer le type d'erreur et renvoyer différents messages d'erreur.

4. Résumé

Dans Golang, la gestion des erreurs est une tâche très importante. Lorsqu’une erreur se produit dans un programme, nous devons être capables de la trouver rapidement et avec précision et de la gérer. Grâce à l'introduction de cet article, nous comprenons comment déterminer le type d'erreur et maîtriser les méthodes courantes de gestion des erreurs. Dans le même temps, nous avons également remarqué quelques petits détails, comme la nécessité de déterminer si la conversion a réussi lors de l'assertion de type. J'espère que cet article pourra être utile à tout le monde lors de la gestion des erreurs dans Golang.

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!