Comment vérifier une structure vide?

Je définis une structure …

type Session struct { playerId ssortingng beehive ssortingng timestamp time.Time } 

Parfois, je lui assigne une session vide (parce que rien n’est possible)

 session = Session{}; 

Ensuite, je veux vérifier si elle est vide:

 if session == Session{} { // do stuff... } 

De toute évidence, cela ne fonctionne pas. Comment puis-je l’écrire?

Vous pouvez utiliser == pour comparer avec un littéral composite de valeur zéro car tous les champs sont comparables :

 if (Session{}) == session { fmt.Println("is zero value") } 

exemple de terrain de jeux

En raison d’une ambiguïté d’parsing , des parenthèses sont nécessaires autour du littéral composite dans la condition if.

Une alternative à la comparaison de la valeur entière consiste à comparer un champ qui doit être défini sur une valeur différente de zéro dans une session valide. Par exemple, si l’identifiant du lecteur doit être! = “” Dans une session valide, utilisez

 if session.playerId == "" { fmt.Println("is zero value") } 

Voici 3 autres suggestions ou techniques:

Avec un champ supplémentaire

Vous pouvez append un champ supplémentaire pour savoir si la structure a été renseignée ou si elle est vide. Je l’ai intentionnellement nommé ready et non empty parce que la valeur zéro d’un bool est false , donc si vous créez une nouvelle structure comme Session{} son champ ready sera automatiquement false et vous dira la vérité: la structure n’est pas- encore prêt (c’est vide).

 type Session struct { ready bool playerId ssortingng beehive ssortingng timestamp time.Time } 

Lorsque vous initialisez la structure, vous devez définir ready à true . Votre méthode isEmpty() n’est plus nécessaire (bien que vous puissiez en créer une si vous le souhaitez) car vous pouvez simplement tester le champ ready lui-même.

 var s Session if !s.ready { // do stuff (populate s) } 

L’importance de ce champ bool supplémentaire augmente à mesure que la structure augmente ou si elle contient des champs non comparables (par exemple, les valeurs slice, map et function).

Utilisation de la valeur zéro d’un champ existant

Ceci est similaire à la suggestion précédente, mais utilise la valeur zéro d’un champ existant qui est considéré comme non valide lorsque la structure n’est pas vide. La facilité d’utilisation dépend de la mise en œuvre.

Par exemple, si dans votre exemple votre playerId ne peut pas être la ssortingng vide "" , vous pouvez l’utiliser pour tester si votre structure est vide comme ceci:

 var s Session if s.playerId == "" { // do stuff (populate s, give proper value to playerId) } 

Dans ce cas, il convient d’intégrer cette vérification dans une méthode isEmpty() car cette vérification dépend de l’implémentation:

 func (s Session) isEmpty() bool { return s.playerId == "" } 

Et en l’utilisant:

 if s.isEmpty() { // do stuff (populate s, give proper value to playerId) } 

Utilisez le pointeur sur votre structure

La deuxième suggestion consiste à utiliser un pointeur sur votre structure: *Session . Les pointeurs peuvent avoir des valeurs nil , vous pouvez donc les tester:

 var s *Session if s == nil { s = new(Session) // do stuff (populate s) } 

Utiliser reflect.deepEqual fonctionne également, surtout lorsque vous avez une carte dans la structure

 package main import "fmt" import "time" import "reflect" type Session struct { playerId ssortingng beehive ssortingng timestamp time.Time } func (s Session) IsEmpty() bool { return reflect.DeepEqual(s,Session{}) } func main() { x := Session{} if x.IsEmpty() { fmt.Print("is empty") } } 

Gardez à l’esprit qu’avec des pointeurs vers la structure, vous devrez déréférencer la variable et ne pas la comparer avec un pointeur sur une structure vide:

 session := &Session{} if (Session{}) == *session { fmt.Println("session is empty") } 

Vérifiez cette aire de jeux .

Ici aussi, vous pouvez voir qu’une structure contenant une propriété qui est une tranche de pointeurs ne peut pas être comparée de la même façon …

Comme alternative aux autres réponses, il est possible de le faire avec une syntaxe similaire à celle que vous avez initialement prévue si vous le faites via une déclaration de case plutôt que if :

 session := Session{} switch { case Session{} == session: fmt.Println("zero") default: fmt.Println("not zero") } 

exemple de terrain de jeux

Peut-être quelque chose comme ça

 package main import "fmt" import "time" type Session struct { playerId ssortingng beehive ssortingng timestamp time.Time } func (s Session) Equal(o Session) bool { if(s.playerId != o.playerId) { return false } if(s.beehive != o.beehive) { return false } if(s.timestamp != o.timestamp) { return false } return true } func (s Session) IsEmpty() bool { return s.Equal(Session{}) } func main() { x := Session{} if x.IsEmpty() { fmt.Print("is empty") } }