Comment utiliser ensemble les mots-clés defer et recovery dans la fonction Golang

Golang est un langage de programmation efficace, concis et facile à apprendre qui a été initialement développé par Google et publié pour la première fois en 2009. Il est conçu pour améliorer la productivité des programmeurs et la clarté du code. Dans Golang, les mots-clés de fonction defer et recovery sont souvent utilisés ensemble pour gérer les erreurs qui peuvent survenir dans le programme. Cet article présentera l'utilisation de ces deux mots-clés et illustrera leur application pratique à travers quelques exemples.

1. Comment utiliser defer

defer est un mot-clé utilisé pour retarder l'exécution d'un code spécifique après l'exécution de la fonction. L'exécution différée signifie que ces codes sont ajoutés à une pile et exécutés les uns après les autres avant le retour de la fonction. La syntaxe de l'instruction

defer est la suivante :

defer function_name(argument)

où function_name est le nom de la fonction qui doit être retardée et argument est une liste de paramètres facultative. Lorsque la fonction termine son exécution et que l'instruction return est exécutée, toutes les instructions defer seront exécutées dans l'ordre.

Ce qui suit est un exemple de programme qui démontre l'utilisation spécifique de l'instruction defer :

package main

import "fmt"

func main() {
    defer fmt.Println("Hello")
    fmt.Println("World")
}

Ce programme affichera "World
Hello" car après avoir exécuté fmt.Println("World"), le programme exécute l'instruction defer, et ajoutez-le à la pile. Lorsque la fonction main() revient, la pile est sautée dans l'ordre et la dernière chose exécutée est l'instruction print dans l'instruction defer.

2. Comment utiliser recovery

Lorsque le programme rencontre une erreur, il arrêtera l'exécution et se terminera. Mais dans certains cas, nous pouvons souhaiter que le programme continue de s'exécuter et de gérer les erreurs. Dans Golang, nous pouvons utiliser le mot-clé recovery pour y parvenir.

recover est une fonction intégrée utilisée uniquement dans les instructions defer, elle est utilisée pour se remettre d'une panique. Lorsqu'un programme panique, il arrête de force l'exécution et reprend l'exécution du programme en appelant la fonction recovery dans l'instruction defer.

Ce qui suit est un exemple de programme qui démontre l'utilisation spécifique de l'instruction recovery :

package main

import (
    "fmt"
    "os"
)

func main() {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("Recovered:", r)
        }
    }()

    fmt.Println("Start")
    panic("Something wrong")
    fmt.Println("End")
    os.Exit(0)
}

Dans ce programme, nous utilisons la fonction recovery dans l'instruction defer de la fonction main(). La fonction anonyme dans l'instruction defer détermine si une panique se produit, imprime les informations pertinentes et reprend l'exécution du programme lorsque la panique se produit.

Lors de l'exécution de ce programme, nous verrons d'abord la sortie "Démarrer", puis le programme déclenchera une panique, le flux de contrôle d'exécution sera interrompu et l'instruction d'impression ne sera pas exécutée. Mais puisque nous utilisons la fonction de récupération pour reprendre l'exécution du programme, "Récupéré : quelque chose de mal" sera affiché avant la fin du programme.

3. Utilisation combinée de différer et récupérer

Dans la programmation réelle, différer et récupérer sont généralement utilisés ensemble. Par exemple, lorsqu'un programme doit être annulé en cas d'échec d'une opération, nous pouvons créer une transaction avant le début de l'opération, valider la transaction une fois l'opération terminée, mais lorsque l'opération échoue, utiliser l'instruction defer pour annuler l'opération. Dans le même temps, lorsque nous rencontrons une erreur anormale, nous pouvons utiliser la fonction de récupération pour reprendre l'exécution du programme et effectuer des opérations spécifiques.

Ce qui suit est un exemple de programme sur les opérations de base de données, qui montre comment le report et la récupération sont utilisés ensemble :

package main

import (
    "database/sql"
    "fmt"
    "log"

    _ "github.com/go-sql-driver/mysql"
)

func main() {
    db, err := sql.Open("mysql", "username:password@tcp(host:port)/database")
    if err != nil {
        log.Fatal(err)
    }
    defer db.Close()

    tx, err := db.Begin()
    if err != nil {
        log.Fatal(err)
    }
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("Transaction Rollback:", r)
            tx.Rollback()
        }
    }()
    _, err = tx.Exec("INSERT INTO users(name) VALUES (?)", "Alice")
    if err != nil {
        panic(err)
    }
    _, err = tx.Exec("INSERT INTO users(name) VALUE (?)", "Bob")
    if err != nil {
        panic(err)
    }
    err = tx.Commit()
    if err != nil {
        panic(err)
    }
}

Dans ce programme, nous ouvrons la connexion à la base de données et créons une transaction avant le début de l'opération. Lorsqu'une erreur anormale se produit pendant l'exécution du programme, une panique sera déclenchée et le flux de contrôle du programme passera immédiatement à l'exécution de l'instruction defer dans la fonction anonyme. Dans cette instruction, nous utilisons la fonction de récupération pour restaurer l'exécution normale du programme et effectuer une restauration des transactions.

Lorsque l'exécution du programme réussit, la transaction sera validée et la connexion à la base de données sera fermée. Lorsqu'une erreur anormale se produit, la transaction sera annulée après l'impression du message d'erreur, la connexion à la base de données sera fermée et le programme se fermera.

4. Résumé

defer et recovery sont des mots-clés importants dans Golang. Ils sont souvent utilisés pour gérer les erreurs d'exception qui se produisent dans les programmes. Nous pouvons utiliser le mot-clé defer pour retarder l'exécution de code nécessitant un traitement spécial après l'exécution de la fonction. Lorsqu'une erreur anormale se produit dans le programme, nous pouvons utiliser le mot-clé recovery pour reprendre l'exécution du programme et gérer l'erreur. Dans la programmation réelle, nous pouvons utiliser ces deux mots-clés en combinaison pour gérer les situations anormales pouvant survenir dans le programme et garantir la stabilité et la fiabilité du programme.

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!