Pourquoi la comparaison des structures `time.Time` avec `==` renvoie-t-elle parfois `false` dans Go ?

La perplexité de la comparaison de structures temporelles à l'aide de ==

Considérons un scénario dans lequel vous créez deux structures time.Time avec une date et une heure apparemment identiques valeurs. Cependant, lorsque l'on compare ces structures à l'aide de l'opérateur d'égalité (==), étonnamment, le résultat renvoie faux. Ce phénomène peut être déroutant, mais la raison réside dans l'implémentation sous-jacente de la structure time.Time.

Sous le capot, la structure time.Time dans Golang est définie comme une valeur composite. Selon la spécification, lors de la comparaison des valeurs de structure avec ==, tous leurs champs doivent être comparables, y compris les champs non nuls. La structure Time se compose de divers champs, tels que les secondes, les nanosecondes et, surtout, un pointeur de localisation.

Le rôle des pointeurs de localisation dans l'égalité de la structure temporelle

Ceci Le pointeur de localisation pointe vers un objet de localisation spécifique et sert de référence au fuseau horaire ou de décalage par rapport à l'heure UTC. Lorsque l'on compare deux structures temporelles à l'aide de ==, la comparaison s'étend non seulement aux secondes et aux nanosecondes, mais également aux pointeurs d'emplacement qu'elles contiennent. Le problème survient lorsque deux structures temporelles avec des valeurs de date et d’heure identiques font référence à des objets Location différents, même s’ils représentent le même emplacement. Dans de tels cas, l'opérateur d'égalité signale faux.

Débogage du problème du pointeur de localisation

Pour vérifier ce comportement, considérez le code suivant :

t1 := time.Date(2016, 4, 14, 1, 30, 30, 222000000, time.UTC)
t2 := time.Unix(0, t1.Sub(time.Date(1970, 1, 1, 0, 0, 0, 0, t1.Location())).Nanoseconds())

fmt.Println("Locations:", t1.Location(), t2.Location())
fmt.Printf("Location pointers: %p %p\n", t1.Location(), t2.Location())
fmt.Println("Locations equal:", t1.Location() == t2.Location())

La sortie de ce code démontre la différence : les emplacements sont les mêmes, mais les pointeurs d'emplacement auxquels ils font référence sont différents, ce qui entraîne le retour de l'opérateur d'égalité false.

Résoudre le problème : utiliser la méthode UTC ou In()

Pour garantir que deux structures temporelles sont considérées comme égales en fonction de leurs valeurs temporelles et non de leurs pointeurs de localisation , il existe plusieurs options. Tout d'abord, vous pouvez appeler la méthode UTC() sur les deux structures temporelles pour définir leur emplacement sur UTC. Cela garantit qu'ils partagent le même objet Location et réussissent ainsi la comparaison d'égalité.

Vous pouvez également utiliser la méthode In() pour définir explicitement l'emplacement des structures temporelles à l'emplacement souhaité. En fournissant le même emplacement comme argument à la méthode In() pour les deux structures temporelles, vous pouvez garantir leur égalité lors de l'utilisation de l'opérateur ==.

Conclusion

Comprendre les subtilités de la structure time.Time, en particulier le rôle du pointeur Location, est essentiel pour comparer correctement les valeurs de temps dans Go. En prenant en compte ces nuances, les développeurs peuvent garantir des comparaisons temporelles précises et cohérentes dans leur base de code.

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!