Français
Français
Lors du traitement des nombres de points flottants dans PHP, Is_infinite () est une fonction utilisée pour déterminer si une variable est infinie. Bien qu'il s'agisse de la sémantique eux-mêmes, en raison des propriétés de calcul des nombres à virgule flottante et du système de type lâche de PHP, s'ils sont utilisés mal, certains problèmes difficiles à obstacles se poseront. Cet article explorera les pièges courants lors du jugement des valeurs de point flottante en utilisant iS_Infinite () et fournira des suggestions pratiques pour éviter ces problèmes.
Les valeurs infinies apparaissent généralement dans les situations suivantes:
Opération illégale de division zéro (comme 1,0 / 0,0 )
Débordement causé par une explosion exponentielle (comme Exp (10000) )
Les données importées dans d'autres langues ou systèmes elle-même ont des valeurs infinies (comme JSON, API Renvoie)
Ces cas produiront des valeurs Inf ou -Inf , qui sont considérées comme infinies en PHP et peuvent être identifiées par is_infinite () .
$val = 1.0 / 0.0;
if (is_infinite($val)) {
echo "La valeur est infiniment grande";
}
De nombreux développeurs appellent uniquement IS_Infinite () sur le résultat final, mais ignorent les résultats de calcul des étapes intermédiaires peuvent être infinies. Par exemple:
$a = 1e308;
$b = 1e308;
$c = $a * $b;
if (!is_infinite($c)) {
echo "Sécurité informatique";
} else {
echo "Le débordement s'est produit";
}
Dans le code ci-dessus, le résultat $ A * $ b sera inf , même si $ a et $ b eux-mêmes sont légaux. Par conséquent, les vérifications doivent également être insérées dans les étapes de calcul critiques, plutôt que de simplement regarder le résultat final.
Lors du traitement des valeurs des points flottants analysés à partir d'API externes ou de JSON, des données contenant Inf ou -INF peuvent être rencontrées. Json_encode () de php et json_decode () ne peut pas gérer correctement ces valeurs par défaut:
$data = ['value' => INF];
$json = json_encode($data);
// retour false，parce que INF C'est illégal JSON valeur
Pour gérer ce type de situation, vous pouvez personnaliser la logique de filtrage:
function safe_json_encode($data) {
array_walk_recursive($data, function (&$item) {
if (is_infinite($item)) {
$item = ($item > 0) ? 'INF' : '-INF';
}
});
return json_encode($data);
}
Ou vérifiez avant de lire une source externe:
$json = file_get_contents('https://gitbox.net/api/data');
$data = json_decode($json, true);
if (is_infinite($data['value'])) {
// Faire des erreurs
}
Lorsque vous triez ou comparez un tableau avec des valeurs infinies, vous pouvez ressentir une erreur logique. Par exemple:
$values = [1.5, INF, 3.0];
sort($values);
Bien que Inf soit correctement classé dernier, si le jugement suivant se produit dans la logique métier:
if ($values[2] > 1000000) {
// Si cela signifie vraiment hors de portée？
}
Dans ce cas, vous devez clairement déterminer s'il est infini, plutôt que de le comparer à un certain seuil.
Vérification explicite des opérations de clés: l'appel is_infinite () après tous les calculs pouvant conduire à des valeurs extrêmes.
Nettoyage des données externes: prétraitez toutes les valeurs d'entrée du point flottant, supprimez -les ou remplacez-les par la valeur maximale acceptable de l'entreprise.
Fonction de vérification de l'encapsulation: Établissez une méthode de vérification de la valeur à virgule flottante unifiée, telle que:
function is_valid_float($val) {
return is_float($val) && !is_nan($val) && !is_infinite($val);
}
Définissez des restrictions commerciales sur les résultats: par exemple, limitez les valeurs de points flottants tels que le prix et le montant d'une plage raisonnable:
if ($amount > 1e12 || is_infinite($amount)) {
throw new Exception("Montant non valide");
}
L'utilisation d'Is_infinite () en PHP semble simple, mais derrière elle, il existe plusieurs risques potentiels tels que la précision des points flottants, la vérification des entrées et le traitement des limites. Les développeurs doivent être vigilants lors de la conception de la logique à virgule flottante et utilisent raisonnablement les fonctions de vérification des limites et de vérification des données pour éviter efficacement les risques de comportement ou de sécurité imprévisibles pendant l'exécution. En identifiant et en traitement correctement le débordement des points flottants, la robustesse et la stabilité du système peuvent être considérablement améliorées.
