Français
Français
Dans le développement de PHP, la gestion des données d'exception est une partie très importante. Surtout lors du traitement des calculs numériques ou de la saisie des utilisateurs, des erreurs imprévisibles sont souvent rencontrées, telles que des nombres non valides ou des données non nucères. Si ces données d'exception ne sont pas correctement traitées, elles peuvent provoquer des accidents de programme, des erreurs logiques ou renvoyer des résultats incorrects.
PHP fournit la fonction is_nan pour nous aider à détecter s'il s'agit d'une valeur "non-nombre" (nan, pas-un nombre). Il s'agit d'un outil très utile, surtout lorsqu'il est nécessaire de vérifier et de tolérer les données qui ne répondent pas aux attentes. Cet article présentera comment utiliser la fonction IS_NAN pour améliorer la tolérance aux défauts de votre code et vous assurer que votre application peut gérer les données illégales plus robuste.
NAN (Not-A-Number) est une valeur spéciale indiquant un nombre non valide. Dans les calculs de points flottants, si certaines opérations (comme 0 divisées par 0) donnent des résultats non représentés, PHP renvoie NAN. Nan n'est pas une erreur, mais représente le résultat d'une opération mathématique infructueuse.
Vous pouvez vérifier si une variable est une valeur nan via la fonction is_nan . La valeur de retour de la fonction is_nan est une valeur booléenne: si le paramètre est nan, il renvoie true ; Sinon, il renvoie faux .
<?php
$value = sqrt(-1); // Racine carrée du nombre négatif，s'avérer NaN
if (is_nan($value)) {
echo "Ceci est un numéro non valide（NaN）。";
} else {
echo "Ceci est un nombre valide。";
}
?>
Dans l'exemple ci-dessus, nous essayons de calculer la racine carrée du nombre négatif et le résultat est NAN . Grâce à la fonction is_nan , nous pouvons le détecter et le traiter en conséquence.
La fonction is_nan est principalement utilisée pour gérer les situations où des valeurs NAN peuvent se produire. Par exemple, lorsque vous recevez une entrée utilisateur ou en obtenant des données d'une API externe, vous ne pouvez pas garantir que les données sont toujours un numéro légitime. À ce stade, nous pouvons utiliser IS_NAN pour vérifier si les données d'entrée sont valides, évitant ainsi les résultats de calcul incorrects.
Par exemple, supposons que nous développons une application de calculatrice où l'utilisateur peut saisir deux valeurs et sélectionner les opérations. Si l'utilisateur entre dans une valeur numérique non valide (comme une lettre, une chaîne vide ou un NAN ), notre application devrait être en mesure de gérer ces erreurs avec élégance, plutôt que de s'écraser ou de renvoyer des résultats dénués de sens.
<?php
function safeDivide($numerator, $denominator) {
if (is_nan($numerator) || is_nan($denominator)) {
return "erreur：Les données d'entrée sont non valides。";
}
if ($denominator == 0) {
return "erreur：Ne peut pas être divisé par zéro。";
}
return $numerator / $denominator;
}
echo safeDivide(10, 2); // Sortir：5
echo safeDivide(10, 0); // Sortir：erreur：Ne peut pas être divisé par zéro。
echo safeDivide("abc", 2); // Sortir：erreur：Les données d'entrée sont non valides。
?>
Dans cet exemple, nous utilisons IS_NAN pour nous assurer que le numérateur et le dénominateur sont des nombres valides. Si la valeur d'entrée est des données NAN ou non valides, nous renvoyons un message d'erreur au lieu de poursuivre l'opération.
La fonction IS_NAN peut être utilisée en conjonction avec d'autres fonctions PHP pour fournir une tolérance de défaut plus complète. Par exemple, en combinant Filter_Var et IS_NAN , vous pouvez d'abord vérifier si les données sont un numéro juridique, puis vérifier davantage s'il s'agit de NAN .
<?php
function validateNumber($input) {
if (!is_numeric($input)) {
return "erreur：L'entrée n'est pas un nombre。";
}
$inputValue = (float)$input;
if (is_nan($inputValue)) {
return "erreur：L'entrée est un numéro non valide（NaN）。";
}
return "L'entrée est un nombre valide：$inputValue";
}
echo validateNumber("abc"); // Sortir：erreur：L'entrée n'est pas un nombre。
echo validateNumber("10.5"); // Sortir：L'entrée est un nombre valide：10.5
echo validateNumber("NaN"); // Sortir：erreur：L'entrée est un numéro non valide（NaN）。
?>
Dans ce code, utilisez d'abord IS_NUMERIC pour vérifier si l'entrée est un nombre, puis utilisez IS_NAN pour confirmer si le nombre est valide.
Dans certains cas, les programmes PHP obtiennent des données de l'URL pour le traitement. Par exemple, si vous obtenez des numéros de l'URL via une demande GET et effectuez des calculs, vous pouvez rencontrer des données illégales ou non valides. À l'heure actuelle, l'utilisation de la fonction IS_NAN peut effectivement empêcher le programme de s'écraser en raison de données non valides.
Supposons que nous passons un paramètre numérique via une demande GET et que nous voulions effectuer des opérations de division, nous pouvons le gérer comme ceci:
<?php
$numerator = isset($_GET['numerator']) ? $_GET['numerator'] : 0;
$denominator = isset($_GET['denominator']) ? $_GET['denominator'] : 1;
if (is_nan((float)$numerator) || is_nan((float)$denominator)) {
echo "erreur：URL Les paramètres contiennent des données non valides。";
} else {
echo "résultat：" . ($numerator / $denominator);
}
?>
Cet extrait de code prend les paramètres du numérateur et du dénominateur de l'URL pour vérifier qu'ils sont des nombres valides. Si le paramètre n'est pas valide, un message d'erreur est renvoyé.
La fonction IS_NAN de PHP est très utile lors de la gestion des données d'exception. Il peut effectivement empêcher les accidents du programme ou des calculs incorrects causés par des nombres non valides (NANS). Dans le développement réel, la combinaison de l'IS_NAN et d'autres fonctions de vérification peuvent améliorer la tolérance aux défauts du programme aux données d'exception, assurer l'expérience utilisateur et la robustesse du programme.
Grâce à un traitement raisonnable de tolérance aux défauts, nous pouvons non seulement éviter les erreurs de programme, mais aussi mieux guider les utilisateurs pour corriger les données qu'ils entrent, améliorant ainsi la stabilité et la fiabilité de l'application.
