Diverses utilisations du mot-clé defer dans les fonctions Golang

Golang est un langage de programmation très populaire avec des fonctionnalités de langage très riches, dont l'utilisation du mot-clé defer pour compléter certaines fonctions spécifiques. Dans cet article, nous présenterons différentes manières d’utiliser le mot-clé defer.

1. Retarder l'exécution de la fonction

Dans Golang, la fonction la plus couramment utilisée du mot-clé defer est de retarder l'exécution de la fonction . Cela signifie qu'une fois la fonction exécutée, la fonction enveloppée par le mot-clé defer sera retardée.

Par exemple, nous pouvons utiliser le mot-clé defer pour imprimer le journal :

func foo() {
    defer log.Printf("Exiting foo()")
    // Do something ...
}

De cette façon, lorsque la fonction termine son exécution, le journal sera imprimé.

2. Retarder la libération des ressources

Dans Golang, l'exécution de fonctions retardées peut également être utilisée pour libérer certaines ressources, comme les fichiers ouverts , connexion Internet, etc.

Par exemple, nous pouvons utiliser le mot-clé defer pour fermer un fichier :

func foo() {
    file, err := os.Open("test.txt")
    if err != nil {
        log.Fatal(err)
    }
    defer file.Close()
    // Do something ...
}

Dans cet exemple de code, lorsque la fonction termine son exécution, le descripteur de fichier sera automatiquement fermé.

De même, nous pouvons également utiliser le mot-clé defer pour fermer une connexion à la base de données :

func foo() {
    db, err := sql.Open("mysql", "user:password@tcp(127.0.0.1:3306)/test")
    if err != nil {
        log.Fatal(err)
    }
    defer db.Close()
    // Do something ...
}

Dans cet exemple de code, lorsque la fonction termine son exécution, la connexion à la base de données sera fermée automatiquement s'arrête.

3. Retarder le traitement des erreurs

Dans Golang, nous pouvons utiliser le mot-clé defer pour retarder le traitement des erreurs. De cette façon, même si une erreur se produit dans la fonction, nous pouvons garantir que la fonction retardée sera exécutée.

Par exemple, nous pouvons utiliser le mot-clé defer pour gérer une erreur d'échec de lecture de fichier :

func foo() (err error) {
    file, err := os.Open("test.txt")
    if err != nil {
        return err
    }
    defer func() {
        if closeErr := file.Close(); closeErr != nil {
            err = closeErr
        }
    }()
    // Do something ...
    return err
}

Dans cet exemple de code, si le fichier ne s'ouvre pas, une erreur est renvoyée directement ; Sinon, nous utilisons le mot-clé defer pour retarder la fermeture du handle de fichier. En même temps, nous avons vérifié s'il y avait une erreur dans l'opération de fermeture dans la fonction defer. Si c'est le cas, l'erreur de fermeture et l'erreur d'origine seront renvoyées.

4. Delayed Recovery

Dans Golang, on peut utiliser le mot-clé defer pour récupérer certaines exceptions.

Par exemple, nous pouvons utiliser le mot-clé defer pour récupérer un appel de fonction erroné :

func foo() (err error) {
    defer func() {
        if exception := recover(); exception != nil {
            err = fmt.Errorf("Caught an exception: %v", exception)
        }
    }()
    // Do something ...
    return err
}

Dans cet exemple de code, nous enveloppons la fonction de récupération dans une fonction defer . Si une exception se produit pendant l'exécution de la fonction, nous récupérerons l'exception et imprimerons les informations sur l'exception.

En bref, le mot-clé defer dans Golang est une fonction très puissante qui peut être utilisée pour effectuer diverses tâches, notamment l'exécution retardée de fonctions, la libération retardée de ressources, la gestion retardée des erreurs et la récupération retardée. L'utilisation du mot-clé defer peut rendre notre code plus robuste et plus clair.

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!