Français
Français
En PHP, la comparaison des nombres à virgule flottante a toujours été un problème difficile. En raison de la limitation de précision des nombres à virgule flottante, l'utilisation == OR === directement pour comparer les nombres à virgule flottante peut conduire à des résultats inexacts. Par conséquent, de nombreux développeurs PHP recommandent d'utiliser la fonction BCComp () pour effectuer des comparaisons de points flottants. Cet article analysera en détail pourquoi il est recommandé d'utiliser Bcomp () au lieu de == ou === pour comparer les nombres de points flottants.
Les nombres de points flottants sont couramment utilisés dans les ordinateurs pour représenter les nombres réels, généralement représentés par la norme IEEE 754. Étant donné que les nombres à virgule flottante sont approximativement représentés par des nombres binaires avec des chiffres finis, il ne représente souvent pas avec précision certains nombres décimaux. Par exemple, 0,1 ne peut pas être exprimé avec précision à 0,1 dans un ordinateur, il s'agit en fait d'un nombre proche de 0,1 , et cette erreur de précision peut progressivement s'accumuler dans le calcul.
Lorsque vous utilisez == ou === pour comparer les nombres à virgule flottante, s'il y a une légère différence de précision entre les deux nombres à virgule flottante, les résultats de comparaison peuvent être pires que prévu. Par exemple:
<span><span><span class="hljs-variable">$a</span></span><span> = </span><span><span class="hljs-number">0.1</span></span><span> + </span><span><span class="hljs-number">0.2</span></span><span>;
</span><span><span class="hljs-variable">$b</span></span><span> = </span><span><span class="hljs-number">0.3</span></span><span>;
</span><span><span class="hljs-keyword">if</span></span><span> (</span><span><span class="hljs-variable">$a</span></span><span> == </span><span><span class="hljs-variable">$b</span></span><span>) {
</span><span><span class="hljs-keyword">echo</span></span><span> </span><span><span class="hljs-string">"égal"</span></span><span>;
} </span><span><span class="hljs-keyword">else</span></span><span> {
</span><span><span class="hljs-keyword">echo</span></span><span> </span><span><span class="hljs-string">"不égal"</span></span><span>;
}
</span></span>Le code ci-dessus peut sortir "inégal" dans certains environnements, car 0,1 + 0,2 n'est pas exactement égal à 0,3 dans un ordinateur, qui est la manifestation du problème de précision du point flottant.
BCComp () est une fonction de PHP qui est spécialement utilisée pour comparer les nombres à virgule flottante avec une précision arbitraire. Il est différent de la normale == et === , BCComp () se compare à une chaîne représentant des nombres de points flottants et vous permet de spécifier la précision de la comparaison.
La syntaxe de la fonction BCComp () est la suivante:
<span><span><span class="hljs-title function_ invoke__">bccomp</span></span><span>(</span><span><span class="hljs-keyword">string</span></span><span> </span><span><span class="hljs-variable">$left_operand</span></span><span>, </span><span><span class="hljs-keyword">string</span></span><span> </span><span><span class="hljs-variable">$right_operand</span></span><span>, </span><span><span class="hljs-keyword">int</span></span><span> </span><span><span class="hljs-variable">$scale</span></span><span> = </span><span><span class="hljs-number">0</span></span><span>): </span><span><span class="hljs-keyword">int</span></span><span>
</span></span>$ Left_Operand et $ right_opeand sont deux numéros de points flottants à comparer et doivent être passés en tant que chaîne.
Le paramètre de l'échelle $ spécifie le nombre maximum de chiffres après le point décimal, c'est-à-dire la précision conservée pendant la comparaison.
La fonction bcomp () renvoie une valeur entière:
Si le premier paramètre est supérieur au deuxième paramètre, retournez 1;
Si les deux paramètres sont égaux, retournez 0;
Si le premier paramètre est plus petit que le deuxième paramètre, retournez -1.
En utilisant BCComp (), nous pouvons nous assurer que la précision des comparaisons à virgule flottante est contrôlée dans la plage attendue, plutôt que d'être affectée par des erreurs de représentation de point flottante informatique.
Afin de comparer les nombres à virgule flottante à l'aide de BCComp () , nous devons convertir les nombres à virgule flottante au format de chaîne et définir la précision appropriée. Par exemple:
<span><span><span class="hljs-variable">$a</span></span><span> = </span><span><span class="hljs-number">0.1</span></span><span> + </span><span><span class="hljs-number">0.2</span></span><span>;
</span><span><span class="hljs-variable">$b</span></span><span> = </span><span><span class="hljs-number">0.3</span></span><span>;
</span><span><span class="hljs-keyword">if</span></span><span> (</span><span><span class="hljs-title function_ invoke__">bccomp</span></span><span>((</span><span><span class="hljs-keyword">string</span></span><span>)</span><span><span class="hljs-variable">$a</span></span><span>, (</span><span><span class="hljs-keyword">string</span></span><span>)</span><span><span class="hljs-variable">$b</span></span><span>, </span><span><span class="hljs-number">10</span></span><span>) == </span><span><span class="hljs-number">0</span></span><span>) {
</span><span><span class="hljs-keyword">echo</span></span><span> </span><span><span class="hljs-string">"égal"</span></span><span>;
} </span><span><span class="hljs-keyword">else</span></span><span> {
</span><span><span class="hljs-keyword">echo</span></span><span> </span><span><span class="hljs-string">"不égal"</span></span><span>;
}
</span></span>Dans cet exemple, nous convertissons les numéros de points flottants $ A et $ B en une chaîne et définissons la précision sur 10 bits. Cela évitera des comparaisons erronées dues à des représentations de points flottants inexacts.
BCCOMP () vous permet de spécifier la précision de la comparaison via le paramètre de l'échelle $ . Ceci est particulièrement important pour les nombres de points flottants impliquant la finance, l'informatique scientifique et d'autres domaines. Dans ces champs, la précision des nombres à virgule flottante est élevée, donc une comparaison précise est cruciale.
Par exemple, dans les applications financières, les valeurs flottantes telles que le prix et le montant peuvent impliquer plusieurs chiffres après le point décimal. Si la précision n'est pas contrôlée, cela peut entraîner des erreurs subtiles, comme le calcul de quelques cents de moins, ou même provoquer des erreurs logiques.
<span><span><span class="hljs-variable">$price1</span></span><span> = </span><span><span class="hljs-string">"10.005"</span></span><span>;
</span><span><span class="hljs-variable">$price2</span></span><span> = </span><span><span class="hljs-string">"10.00499"</span></span><span>;
</span><span><span class="hljs-keyword">if</span></span><span> (</span><span><span class="hljs-title function_ invoke__">bccomp</span></span><span>(</span><span><span class="hljs-variable">$price1</span></span><span>, </span><span><span class="hljs-variable">$price2</span></span><span>, </span><span><span class="hljs-number">4</span></span><span>) == </span><span><span class="hljs-number">0</span></span><span>) {
</span><span><span class="hljs-keyword">echo</span></span><span> </span><span><span class="hljs-string">"价格égal"</span></span><span>;
} </span><span><span class="hljs-keyword">else</span></span><span> {
</span><span><span class="hljs-keyword">echo</span></span><span> </span><span><span class="hljs-string">"价格不égal"</span></span><span>;
}
</span></span>Dans cet exemple, en définissant la précision sur 4, nous pouvons nous assurer qu'il n'y a pas d'erreurs causées par des problèmes de précision lors de la réalisation de comparaisons de prix.
Bien que == et === soient très courants en PHP, ils ne conviennent pas aux comparaisons de points flottants. Les raisons spécifiques sont les suivantes:
== : Les deux opérandes sont convertis de type pendant la comparaison, ce qui peut conduire à des résultats indésirables. Lors de la comparaison des nombres à virgule flottante, == ignore le problème de précision et se soucie seulement de savoir si les deux valeurs sont égales, mais cette comparaison peut entraîner des erreurs en raison de l'erreur de représentation des nombres à virgule flottante.
=== : == Aucune conversion de type n'est effectuée, mais il nécessite que deux nombres à virgule flottante aient non seulement des valeurs égales, mais ont également exactement le même type et la même représentation. En raison de l'erreur de précision des nombres de points flottants, === peut renvoyer faux même si les deux valeurs sont très proches.
Par exemple:
<span><span><span class="hljs-variable">$a</span></span><span> = </span><span><span class="hljs-number">0.1</span></span><span> + </span><span><span class="hljs-number">0.2</span></span><span>;
</span><span><span class="hljs-variable">$b</span></span><span> = </span><span><span class="hljs-number">0.3</span></span><span>;
</span><span><span class="hljs-title function_ invoke__">var_dump</span></span><span>(</span><span><span class="hljs-variable">$a</span></span><span> == </span><span><span class="hljs-variable">$b</span></span><span>); </span><span><span class="hljs-comment">// false</span></span><span>
</span><span><span class="hljs-title function_ invoke__">var_dump</span></span><span>(</span><span><span class="hljs-variable">$a</span></span><span> === </span><span><span class="hljs-variable">$b</span></span><span>); </span><span><span class="hljs-comment">// false</span></span><span>
</span></span>C'est précisément en raison de l'existence d'erreurs de précision à virgule flottante que l'utilisation == ou === pour comparer les nombres à virgule flottante n'est pas toujours fiable.
En raison de la limitation de précision des nombres à virgule flottante, l'utilisation == ou === pour comparer directement les nombres à virgule flottante peut conduire à des résultats inexacts. Pour résoudre ce problème, il est recommandé d'utiliser la fonction BCComp () , qui fournit une méthode plus précise pour comparer les nombres à virgule flottante et permet aux développeurs de contrôler la précision de la comparaison, en évitant les erreurs potentielles causées par des représentations de nombres à virgule flottante inexactes. Dans les scénarios impliquant des comparaisons de haute précision, BCComp () est un choix plus fiable et plus sûr.
