Comment gérer correctement la libération des ressources avec « defer » dans les boucles lors de l'interrogation des bases de données ?

Libération appropriée des ressources avec report dans les boucles

Interrogation d'une base de données à l'intérieur d'une boucle

Dans une boucle dans laquelle vous devez effectuer des requêtes SQL sur une base de données, vous pouvez structurer votre code comme suit :

for rows.Next() {
   fields, err := db.Query(.....)
   if err != nil {
      // ...
   }
   defer fields.Close()

   // do something with `fields`

}

Cependant, il existe différentes manières de gérer la libération des ressources en utilisant le report dans de tels scénarios.

Déplacer le report en dehors de la boucle

Une option consiste à déplacer l'instruction defer en dehors de la boucle, comme indiqué ci-dessous :

for rows.Next() {
   fields, err := db.Query(.....)
   if err != nil {
      // ...
   }

   // do something with `fields`
}

defer fields.Close()

Utilisation Fonctions anonymes

Une autre approche consiste à envelopper le code d'allocation de ressources dans une fonction anonyme et à placer l'instruction defer dans cette fonction :

for rows.Next() {
    func() {
        fields, err := db.Query(...)
        if err != nil {
            // Handle error and return
            return
        }
        defer fields.Close()

        // do something with `fields`
    }()
}

Gestion des erreurs dans un fichier nommé Fonction

Vous pouvez également créer une fonction nommée pour gérer les erreurs reporting :

func foo(rs *db.Rows) error {
    fields, err := db.Query(...)
    if err != nil {
        return fmt.Errorf("db.Query error: %w", err)
    }
    defer fields.Close()

    // do something with `fields`
    return nil
}

for rows.Next() {
    if err := foo(rs); err != nil {
        // Handle error and return
        return
    }
}

Gestion de l'erreur Rows.Close()

Étant donné que Rows.Close() renvoie une erreur, vous souhaiterez peut-être la vérifier. Cela peut être fait à l'aide d'une fonction anonyme :

func foo(rs *db.Rows) (err error) {
    fields, err := db.Query(...)
    if err != nil {
        return fmt.Errorf("db.Query error: %w", err)
    }
    defer func() {
        if err = fields.Close(); err != nil {
            err = fmt.Errorf("Rows.Close() error: %w", err)
        }
    }()

    // do something with `fields`
    return nil
}

Conclusion

L'approche correcte pour libérer des ressources avec report en boucle dépend de vos besoins spécifiques et de votre gestion des erreurs exigences. En examinant attentivement les options présentées ci-dessus, vous pouvez assurer une bonne gestion des ressources et éviter les fuites de ressources.

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!