Français
Français
Dans la programmation PHP, la fonction CEIL () est souvent utilisée pour arrondir les nombres de points flottants vers le haut, en particulier dans des scénarios tels que la pagination, le calcul des prix et le traitement par lots. Cependant, lorsqu'il est utilisé avec les opérations de division, si les décimales ne sont pas gérées strictement, cela peut provoquer des erreurs logiques indétectables. Cet article creusera ce malentendu commun et ses solutions.
Imaginez un système de pagination qui affiche 10 éléments de données par page, avec un total de 95 éléments de données. Une façon typique de calculer le nombre total de pages est la suivante:
<code> $ totalItems = 95; $ itemsperpage = 10; $ totalpages = ceil ($ totalItems / $ itemsperpage); Echo $ TotalPages; // Sortie: 10 </code>Dans cet exemple simple, la sortie est correcte. Mais une fois que la source de valeur de $ totaltems est incertaine, comme à partir de l'entrée utilisateur ou de l'API externe, ou en utilisant des résultats de division entier, des problèmes peuvent survenir.
Par exemple:
<code> $ totalItems = intval ("95.4"); // est géré comme 95 par erreur $ itemsperpage = 10; $ totalpages = ceil ($ totalItems / $ itemsperpage); // L'attente réelle est de 10 pages Echo $ TotalPages; // Sortie réelle: 10 </code>Bien que ce résultat soit correct, en supposant que le total est de 94,1 , le lancer dans un entier entraînera un comptage moins:
<code> $ totalItems = intval ("94.1"); // est traité comme 94 $ TotalPages = CEIL ($ TotalItems / 10); // ceil (9.4) => 10 </code>Si vous continuez à pousser vers le bas, par exemple, vous comptez sur d'autres calculs pour obtenir une décimale, mais vous ne convertiez pas explicitement le résultat de la division en un numéro de point flottant:
<code> $ totalItems = 94; $ itemsperpage = 10; $ totalpages = ceil ($ totalItems / $ itemsperpage); // ceil (9.4) => 10 </code>Le résultat correct est toujours sorti ici. Mais si vous utilisez plutôt un diviseur:
<code> $ totalPages = ceil (intdiv ($ totalItems, $ itemsperpage)); // intdiv (94, 10) => 9 </code>Ce résultat est faux, car intdiv () rejette directement la partie décimale, et le résultat arrondi et ceil () ont perdu son sens.
De nombreux développeurs pensent que tant qu'ils utilisent ceil () , le résultat doit être correct et ignorer que le cel d'entrée () dépend doit être un numéro de point flottant exact. Une fois qu'une certaine partie du processus de division est divisible, ou que le résultat intermédiaire est rejeté à partir des décimales dues à la conversion de type, alors ceil () peut s'exécuter en fonction de la mauvaise entrée.
De plus, certaines bases de données renvoient les résultats s'ils sont des chaînes, PHP aura une erreur lors de la conversion par défaut:
<code> $ result = "94.8"; // la chaîne $ totalpages obtenue à partir de la base de données = ceil ($ result / 10); // Convertissez automatiquement en numéros de points flottants, mais assurez-vous que le format est correct </code>Si le résultat est traité dans un format non standard, comme l'utilisation de décimales séparées par des virgules (format européen), il ne sera pas converti correctement en un numéro de point flottant, qui à son tour affectera la sortie de ceil () .
Pour éviter les problèmes ci-dessus, l'approche recommandée consiste à gérer explicitement le type et la précision pour garantir que ceil () reçoit la valeur du point flottante exact:
Utiliser (flotter) CAST:
<code> $ totalpages = ceil ((float) $ totalItems / (float) $ itemsperpage);
</code>
Évitez d'utiliser intdiv () et ceil () pour mélanger. Si vous devez utiliser une division Integer, il est recommandé de juger en fonction du reste:
<code> $ totalpages = intdiv ($ totalItems, $ itemsperpage);
if ($ totalitems% $ itemsperpage> 0) {
$ totalpages + = 1;
}
</code>
Pour la saisie des utilisateurs ou des API, il est recommandé d'utiliser FloatVal () au lieu d' IntVal () , comme:
Lors de l'utilisation de la fonction ceil () de PHP, si la décimale n'est pas correctement gérée avec la division, il est très facile de provoquer des erreurs logiques. Surtout dans la pagination ou le comptage de la logique, les résultats peuvent sembler "presque corrects", mais il existe des vulnérabilités de précision réelles.
Les développeurs doivent se méfier des pièges de la conversion de type implicite et de la division entière, restent sensibles aux types de données et assurent la rigueur et l'exactitude de la logique du programme par la conversion explicite et le jugement raisonnable.
