Golang obtient une erreur de programme

Dans le développement de programmes, la gestion des erreurs est une tâche très importante. Lorsque le programme rencontre une erreur, elle doit être découverte et traitée à temps, sinon le programme tout entier plantera. Dans Golang, le mécanisme de gestion des erreurs intégré peut nous aider à mieux gérer les erreurs de programme. Cet article explique comment obtenir des erreurs de programme dans Golang.

Gestion des erreurs

Dans Golang, les erreurs sont traitées comme un type, c'est-à-dire le type erreur. Normalement, lorsqu'une fonction renvoie une valeur de type error, cela signifie que la fonction peut renvoyer une erreur. error 类型。通常情况下，当一个函数返回一个 error 类型的值时，表示该函数可能会返回错误。

下面是一个返回字符串长度的函数 StringLength，当传入的字符串为空时，会返回一个错误：

func StringLength(str string) (int, error) {
    if str == "" {
        return 0, errors.New("String is empty")
    }
    return len(str), nil
}

在上面的代码中，errors.New 方法用于创建一个 error 类型的对象。

当我们调用 StringLength 时，需要检查返回的错误对象是否为空，以确定函数是否成功执行：

str := "hello world"
length, err := StringLength(str)
if err != nil {
    fmt.Println("Error:", err)
    return
}
fmt.Printf("The length of "%s" is %d
", str, length)

输出：

The length of "hello world" is 11

当传入的字符串为空时，输出：

Error: String is empty

通过上述例子，可以看出 Golang 的错误处理机制非常直观和简单。

错误信息详情

有时候我们需要获取更多关于错误的细节信息，比如执行错误位置、错误码等。在 Golang 中，可以通过 errors 包的 Wrap 函数将原始错误和新的错误信息包装在一起，并返回一个新的错误值。这个新的错误值携带了原始错误和自定义的错误信息，可以提供更多的错误细节。

下面是一个例子：

func Divide(x, y float64) (float64, error) {
    if y == 0 {
        return 0, errors.New("division by zero")
    }
    return x / y, nil
}

func main() {
    x, y, err := 4.0, 0.0, error(nil)
    
    // 错误发生在这里
    result, err := Divide(x, y)
    if err != nil {
        err = errors.Wrap(err, "can't perform division")
    }
    fmt.Printf("Result: %v, error: %v", result, err)
}

当使用 Wrap 方法包装错误时，它会添加一个前缀并返回一个新的错误对象，其中包含原始错误及新的错误信息。在这个例子中，我们使用了 Wrap 方法，并在新的错误信息中添加了 "can't perform division" 的前缀。

此时输出的错误信息如下：

Result: 0, error: can't perform division: division by zero

可以看到，错误信息中包含了自定义的错误信息和原始错误信息。

panic

当一个 Goroutine 遇到一个无法恢复的错误或异常时，可以使用 panic 函数向上传递一个错误信息，并终止程序的执行。任何上层函数都有机会处理这个错误，或者将其向更高层的函数传递，直到程序停止运行。

下面是一个例子：

func processFile(filename string) error {
    file, err := os.Open(filename)
    if err != nil {
        return errors.Wrap(err, "can't open file")
    }
    defer file.Close()

    // ... process file

    if err != nil {
        panic(errors.Wrap(err, "can't process file"))
    }

    return nil
}

在上面的代码中，当文件处理失败时，我们使用 panic 函数汇报了错误，并希望其他 Goroutine 或程序能处理它。可以在调用 processFile 的代码中使用 recover 函数捕获 panic 并进行错误处理。

func main() {
    defer func() {
        if p := recover(); p != nil {
            fmt.Printf("Recovered from panic: %v
", p)
        }
    }()

    err := processFile("test.txt")
    if err != nil {
        fmt.Println(err)
    }
}

以上程序可以正常运行，但当出现错误时，会打印出 panic 信息，并用 recover 函数捕获。

总结

在 Golang 中，错误处理是非常重要的一项工作。通过返回 error 类型的值，并检查其是否为空，可以判断函数是否成功执行。在需要获取更多错误细节时，可以使用 Wrap 函数进行包装。当 Goroutine 遇到无法恢复的错误或异常时，可以使用 panic

Ce qui suit est une fonction qui renvoie la longueur d'une chaîne StringLength Lorsque la chaîne entrante est vide, une erreur sera renvoyée :

rrreee#🎜🎜. # Dans le code ci-dessus, la méthode errors.New est utilisée pour créer un objet de type error.

#🎜🎜#Lorsque nous appelons StringLength, nous devons vérifier si l'objet d'erreur renvoyé est vide pour déterminer si la fonction est exécutée avec succès : #🎜🎜#rrreee#🎜🎜#Output : # 🎜🎜#rrreee#🎜🎜#Lorsque la chaîne entrante est vide, le résultat est : #🎜🎜#rrreee#🎜🎜#Grâce à l'exemple ci-dessus, vous pouvez voir que le mécanisme de gestion des erreurs de Golang est très intuitif et simple. #🎜🎜##🎜🎜#Détails du message d'erreur#🎜🎜##🎜🎜#Parfois, nous avons besoin d'obtenir des informations plus détaillées sur l'erreur, telles que l'emplacement de l'erreur d'exécution, le code d'erreur, etc. Dans Golang, vous pouvez regrouper l'erreur d'origine et les nouvelles informations d'erreur via la fonction Wrap du package errors et renvoyer une nouvelle valeur d'erreur. Cette nouvelle valeur d'erreur contient l'erreur d'origine et les informations d'erreur personnalisées pour fournir plus de détails sur l'erreur. #🎜🎜##🎜🎜#Voici un exemple : #🎜🎜#rrreee#🎜🎜#Lorsqu'une erreur est enveloppée à l'aide de la méthode Wrap, elle ajoute un préfixe et renvoie un nouvel objet d'erreur, Il contient l'erreur d'origine ainsi que de nouvelles informations sur l'erreur. Dans cet exemple, nous utilisons la méthode Wrap et préfixons le nouveau message d'erreur par "can't perform division". #🎜🎜##🎜🎜#Le message d'erreur affiché à ce moment est le suivant : #🎜🎜#rrreee#🎜🎜#Comme vous pouvez le voir, le message d'erreur contient le message d'erreur personnalisé et le message d'erreur d'origine. #🎜🎜##🎜🎜#panic#🎜🎜##🎜🎜#Lorsqu'un Goroutine rencontre une erreur ou une exception irrécupérable, il peut utiliser la fonction panic pour transmettre un message d'erreur vers le haut et mettre fin à l'exécution. du programme. Toute fonction de niveau supérieur a la possibilité de gérer cette erreur ou de la transmettre à une fonction de niveau supérieur jusqu'à ce que le programme s'arrête. #🎜🎜##🎜🎜#Ce qui suit est un exemple : #🎜🎜#rrreee#🎜🎜#Dans le code ci-dessus, lorsque le traitement du fichier échoue, nous utilisons la fonction panic pour signaler l'erreur et J'espère qu'un autre Goroutine ou programme pourra le gérer. Vous pouvez utiliser la fonction recover dans le code qui appelle processFile pour capturer la panique et gérer l'erreur. #🎜🎜#rrreee#🎜🎜#Le programme ci-dessus peut fonctionner normalement, mais lorsqu'une erreur se produit, les informations de panique seront imprimées et capturées avec la fonction récupérer. #🎜🎜##🎜🎜#Résumé#🎜🎜##🎜🎜# Dans Golang, la gestion des erreurs est une tâche très importante. Vous pouvez déterminer si une fonction s'est exécutée avec succès en renvoyant une valeur de type error et en vérifiant si elle est vide. Lorsque vous avez besoin d'obtenir plus de détails sur l'erreur, vous pouvez utiliser la fonction Wrap pour l'encapsulage. Lorsque Goroutine rencontre une erreur ou une exception irrécupérable, vous pouvez utiliser la fonction panic pour transmettre les informations d'erreur vers le haut et mettre fin à l'exécution du programme. #🎜🎜##🎜🎜#Quelle que soit la situation, il est très important de détecter et de traiter les erreurs à temps. Ce n'est qu'ainsi que la fiabilité et la stabilité du programme peuvent être garanties. #🎜🎜#

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!