Comment les fonctions Golang gèrent les erreurs avec élégance

La gestion gracieuse des erreurs dans les fonctions dans Go implique l'astuce suivante : utilisez if err != nil pour vérifier les erreurs. Séparez la logique de gestion des erreurs et utilisez des instructions defer. Utilisez les erreurs sentinelles pour représenter les types d’erreurs connus. Utilisez plusieurs types d’erreurs pour gérer plusieurs types d’erreurs. Cas pratique : Dans les opérations de lecture et d'écriture de fichiers, la robustesse du code peut être améliorée en vérifiant les erreurs et en les traitant de manière appropriée.

Gérer avec élégance les erreurs dans les fonctions Go

Dans Go, les erreurs sont représentées sous forme de variables de type erreur. Une bonne gestion des erreurs est cruciale pour écrire un code robuste et maintenable. Les conseils suivants vous aideront à gérer les erreurs dans vos fonctions avec élégance : error 类型的变量。良好的错误处理对于编写健壮且可维护的代码至关重要。以下技巧将帮助你优雅地处理函数中的错误：

1. 使用 if err != nil

检查错误的最常见方法是使用 if err != nil，如下所示：

func f() error {
    if err := g(); err != nil {
        return fmt.Errorf("g: %w", err) // 使用 %w 封装原始错误
    }

    // 其余代码...
    return nil
}

2. 分离错误处理逻辑

为了保持函数简洁，可以将错误处理逻辑从业务逻辑中分离。defer 语句用于在函数返回之前处理错误，如下所示：

func f() (err error) {
    defer func() {
        if r := recover(); r != nil {
            // 捕获恐慌并将其转换为错误
            err = fmt.Errorf("panic: %v", r)
        }
    }()

    g()

    return
}

3. 使用 sentinel 错误

哨兵错误是一个特殊的错误，用于表示特定类型的错误条件。这使得错误检查更简单，如下所示：

func f() error {
    if err := g(); err == sentinelError {
        return nil // 忽略已知的错误
    }

    return err
}

4. 使用多错误类型

当函数可能产生多种类型的错误时，可以使用多错误类型。errors.NewMultiError()

1. Utilisez if err != nil

La façon la plus courante de vérifier les erreurs est d'utiliser if err. != nil , comme indiqué ci-dessous :

func f() error {
    var errs []error

    if err := g(); err != nil {
        errs = append(errs, err)
    }

    if err := h(); err != nil {
        errs = append(errs, err)
    }

    if len(errs) > 0 {
        return errors.NewMultiError(errs...)
    }

    return nil
}

2. Logique de gestion des erreurs séparée

🎜🎜Afin de garder la fonction simple, la logique de gestion des erreurs peut être séparée de la logique métier. L'instruction defer est utilisée pour gérer les erreurs avant le retour de la fonction, comme indiqué ci-dessous : 🎜

package main

import (
    "fmt"
    "io/ioutil"
)

func main() {
    data, err := ioutil.ReadFile("data.txt")
    if err != nil {
        fmt.Printf("ReadFile: %v", err)
        return
    }

    err = ioutil.WriteFile("data-copy.txt", data, 0644)
    if err != nil {
        fmt.Printf("WriteFile: %v", err)
        return
    }
}

🎜🎜3 Utilisation des erreurs sentinelles🎜🎜🎜Une erreur sentinelle est une erreur spéciale utilisée pour représenter un type spécifique de. condition d'erreur. Cela simplifie la vérification des erreurs, comme indiqué ci-dessous : 🎜rrreee🎜🎜 4. Utilisation de plusieurs types d'erreurs 🎜🎜🎜 Plusieurs types d'erreur peuvent être utilisés lorsqu'une fonction peut produire plusieurs types d'erreurs. La fonction errors.NewMultiError() permet la création d'erreurs contenant plusieurs erreurs, comme indiqué ci-dessous : 🎜rrreee🎜🎜Exemple pratique : lecture et écriture de fichiers🎜🎜🎜L'exemple de code suivant montre comment lire et write Gérez les erreurs avec élégance lors de l'importation de fichiers : 🎜rrreee🎜 En utilisant les conseils ci-dessus, vous pouvez gérer les erreurs avec élégance dans les fonctions Go, améliorant ainsi la robustesse et la maintenabilité de votre code. 🎜

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!