Français
Français
En PHP, nous utilisons souvent la fonction is_nan pour vérifier si une valeur est nan (pas un nombre), et nous utilisons souvent la fonction ronde pour rassembler des nombres flottants. Cependant, lorsqu'ils sont utilisés en combinaison, ces deux fonctions peuvent parfois produire une erreur de précision ou un comportement inattendu. Cet article explorera les causes de ces erreurs et fournira certaines solutions pour éviter efficacement ces problèmes.
La fonction ronde est utilisée pour arrondir les nombres flottants. Il accepte deux paramètres principaux:
round($number, $precision = 0);
Où le nombre $ est le numéro flottant à traiter, et $ précision est le numéro de chiffre de précision arrondi. Si le paramètre de précision est omis, la valeur par défaut est 0.
La fonction is_nan est utilisée pour vérifier si la variable donnée est nan . Nan est un numéro flottant spécial qui signifie "pas un nombre". Par exemple, le résultat de 0/0 est nan .
is_nan($value);
Lorsque vous utilisez la fonction is_nan et ronde en combinaison, la raison de l'erreur est généralement liée à la façon dont le nombre flottant est représenté. Les nombres flottants en PHP sont basés sur la représentation binaire de la norme IEEE 754, qui ne peut parfois pas représenter avec précision certaines valeurs numériques. Par exemple, Round (0,1 + 0,2, 1) peut retourner 0,3 au lieu du résultat que vous attendez.
Cette erreur se reflète généralement dans les situations suivantes:
En raison de la représentation binaire des nombres flottants, certains nombres ne peuvent pas être représentés avec précision.
Lors de l'arrondi, la fonction ronde traite la précision, mais elle est toujours limitée par la précision du numéro flottant.
Lorsque vous utilisez la fonction IS_NAN , vous pouvez rencontrer des situations limites, qui sont liées à la représentation des nombres flottants, entraînant une erreur de jugement comme NAN .
Afin de réduire l'erreur entre la fonction ronde et la fonction is_nan , vous devez d'abord vous assurer de passer une précision appropriée lorsque vous appelez la fonction ronde . Par exemple, évitez les opérations de haute précision inutiles et réduisez les erreurs en nombres flottants.
$value = 0.1 + 0.2;
$rounded_value = round($value, 2); // Autour du résultat à deux décimales
if (is_nan($rounded_value)) {
echo "The value is NaN.";
} else {
echo "The rounded value is: " . $rounded_value;
}
Parfois, la coulée peut aider à éviter certaines erreurs en raison de nombres flottants inexacts. Convertir des nombres flottants en chaînes puis les arrondir, ou la conversion des résultats en entiers, évite généralement certaines erreurs mineures.
$value = 0.1 + 0.2;
$rounded_value = round((int)($value * 100)); // Convertir en entiers pour l'arrondi
if (is_nan($rounded_value)) {
echo "The value is NaN.";
} else {
echo "The rounded value is: " . $rounded_value;
}
Si vous souhaitez éviter une mauvaise évaluation en tant que NAN , vous pouvez créer une fonction de comparaison personnalisée. Cette fonction peut déterminer si elle est NAN en comparant si le nombre flottant est proche d'une valeur prédéterminée.
function is_approx_nan($value, $epsilon = 0.00001) {
return abs($value - NAN) < $epsilon;
}
$value = 0.1 + 0.2;
$rounded_value = round($value, 2);
if (is_approx_nan($rounded_value)) {
echo "The value is approximately NaN.";
} else {
echo "The rounded value is: " . $rounded_value;
}
Lorsque nous utilisons les fonctions IS_NAN et rondes dans PHP, nous pouvons rencontrer le problème de l'erreur de précision des numéros flottants. En comprenant les causes profondes de ces problèmes et en prenant des solutions correspondantes, nous pouvons éviter efficacement l'impact des erreurs.
Ajustez la précision de la fonction ronde pour réduire la perte de précision.
Conversion de type coulé pour éviter une représentation inexacte des nombres flottants.
Utilisez une méthode de comparaison personnalisée pour vérifier si elle est nan .
Grâce à ces méthodes, nous pouvons éviter de mal juger le NAN autant que possible lorsque l'on traite des nombres flottants, assurant la stabilité et la précision du programme.
