Maison >développement back-end >Golang >Pourquoi l'égalité à virgule flottante échoue-t-elle lors de la comparaison de variables et de littéraux ?
L'écart
En Go, le l'extrait de code suivant révèle une différence intrigante en virgule flottante calculs :
package main import ( "fmt" ) func main() { x := 10.1 fmt.Println("x == 10.1: ", x == 10.1) fmt.Println("x*3.0 == 10.1*3.0:", x*3.0 == 10.1*3.0) }
Lors de son exécution, ce code produit des résultats inattendus :
x == 10.1: true x*3.0 == 10.1*3.0: false
Alors que les mêmes opérations à virgule flottante sont effectuées, en utilisant soit une variable déclarée (x) soit un littéral (10.1), le contrôle d'égalité échoue.
Origine de la différence
À Pour comprendre ce comportement, il faut se plonger dans la gestion par Go des nombres à virgule flottante. Les constantes et les littéraux numériques ne sont initialement pas typés et possèdent des caractères de type "无限精度". Cependant, lorsqu'ils sont affectés à une variable ou convertis en type, ils héritent des limitations du type de destination.
Lorsque x := 10.1 est attribué, le littéral 10.1 perd une certaine précision en raison de la conversion en flottant. A l’inverse, 10,1*3,0 conserve toute sa précision dans le calcul. Cela explique la différence de valeurs observée et la fausse vérification d'égalité.
Documentation et justification
Ce comportement est décrit dans la section « Floats » du billet de blog de Go sur constantes :
"Les constantes numériques vivent dans un espace numérique de précision arbitraire ; ce ne sont que des nombres réguliers. Mais lorsqu'elles sont affectées à une variable la valeur doit pouvoir s'adapter à la destination. en Aller. Ces connaissances permettent aux développeurs d'anticiper et de gérer efficacement les problèmes liés à la précision dans leur 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!