Maison >développement back-end >Golang >Comment puis-je vérifier de manière fiable les interfaces nulles et les valeurs nulles dans Go ?

Comment puis-je vérifier de manière fiable les interfaces nulles et les valeurs nulles dans Go ?

Mary-Kate Olsen
Mary-Kate Olsenoriginal
2024-12-11 19:07:12385parcourir

How Can I Reliably Check for Nil Interfaces and Nil Values in Go?

Vérification des interfaces Nil et Nil dans Go

Lorsque vous travaillez avec des interfaces dans Go, il est souvent nécessaire de vérifier si une interface est nulle ou contient une valeur nulle. Cependant, l'approche standard utilisant la réflexion peut être verbeuse et sujette aux erreurs.

Par exemple, considérons la fonction d'assistance suivante :

func isNil(a interface{}) bool {
  defer func() { recover() }()
  return a == nil || reflect.ValueOf(a).IsNil()
}

Cette fonction utilise la réflexion pour vérifier si la valeur est nulle. , mais cela nécessite une récupération différée () pour gérer les paniques lorsque le type de la valeur n'est pas pris en charge.

Une méthode plus directe Approche

Comme le suggère la réponse à la question initiale, une approche plus simple et plus fiable consiste à utiliser la comparaison directe pour les interfaces nulles et à toujours autoriser l'attribution de zéro aux interfaces non typées. Voici comment :

func isNil(a interface{}) bool {
  return a == nil
}

Cette fonction vérifiera correctement à la fois les interfaces nulles et les valeurs nulles au sein des interfaces.

Lorsque l'attribution de (*T)(nil) est autorisée

L'approche décrite ci-dessus suppose que vous n'attribuerez jamais (*T)(nil) à une interface. Si ce n'est pas le cas, vous devrez peut-être utiliser la réflexion pour vérifier les valeurs nulles :

func isNil(a interface{}) bool {
  if a == nil {
    return true
  }
  v := reflect.ValueOf(a)
  if v.Kind() == reflect.Ptr && v.IsNil() {
    return true
  }
  return false
}

Cependant, il est généralement recommandé d'éviter d'attribuer (*T)(nil) aux interfaces, car cela peut conduire aux bugs subtils. En appliquant la règle de ne jamais stocker (*T)(nil) dans les interfaces, vous pouvez simplifier votre code et augmenter sa fiabilité.

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!

Déclaration:
Le contenu de cet article est volontairement contribué par les internautes et les droits d'auteur appartiennent à l'auteur original. Ce site n'assume aucune responsabilité légale correspondante. Si vous trouvez un contenu suspecté de plagiat ou de contrefaçon, veuillez contacter admin@php.cn