Deutsch
Deutsch
In PHP wird die Funktion is_double () verwendet, um festzustellen, ob eine gegebene Variable eine schwimmende Punktzahl der doppelten Präzision ist (d. H. Float -Typ). Schwimmpunkte sind sehr nützlich, wenn sie sehr große oder sehr kleine Werte bezeichnen, aber es gibt einige Fallstricke, insbesondere wenn es um große Werte geht. In diesem Artikel werden einige potenzielle Probleme der Funktion is_double () bei der Überprüfung großer Werte sowie bei der Verwendung von Dingen erörtert.
Floating-Punkt-Zahlen in PHP folgen normalerweise dem IEEE 754-Standard, was bedeutet, dass sie im binären Format gespeichert sind. Nach diesem Standard besteht eine schwimmende Punktzahl aus drei Teilen: dem Zeichenbit, dem Exponententeil und dem Mantissa -Teil. Da Gleitkommazahlen in begrenztem Maße ausgedrückt werden, können sie nicht alle numerischen Werte, insbesondere sehr große oder sehr kleine Werte, genau darstellen. Dies kann zu einem unerwarteten Verhalten führen, insbesondere bei Überprüfung nach großen Werten.
Beispielsweise ist in PHP die Genauigkeit der Gleitkomma-Zahlen begrenzt, normalerweise 15-16-Bit-Dezimalzahlen. Dies bedeutet, dass in einigen Fällen große Werte, die über diesen Präzisionsbereich hinausgehen, möglicherweise nicht genau ausgedrückt werden, was das Urteil der IS_Double () -Funktion beeinflusst.
Wenn der Wert sehr groß ist, wandelt PHP ihn automatisch in eine schwimmende Punktzahl um, was zu einem Genauigkeitsverlust führen kann. Beispielsweise zeigt der folgende Code ein häufiges Problem beim Umgang mit großen Werten:
<span><span><span class="hljs-variable">$bigNumber</span></span><span> = </span><span><span class="hljs-number">12345678901234567890</span></span><span>;
</span><span><span class="hljs-title function_ invoke__">var_dump</span></span><span>(</span><span><span class="hljs-title function_ invoke__">is_double</span></span><span>(</span><span><span class="hljs-variable">$bigNumber</span></span><span>)); </span><span><span class="hljs-comment">// Ausgabe bool(true)</span></span><span>
</span></span>In diesem Code ist $ bInnumber tatsächlich eine sehr große Ganzzahl, die über den Genauigkeitsbereich der schwimmenden Punktzahlen hinausgeht. Wenn der Wert durch PHP in eine schwimmende Punktzahl konvertiert wird, kann eine gewisse Genauigkeit verloren gehen, während IS_DOUBLE () immer noch true zurückgibt, d. H. Die Variable betrachtet eine schwimmende Punktzahl mit doppelter Präzision.
Gleitkomma-Zahlen haben Genauigkeitsbeschränkungen, insbesondere wenn es sich um große Werte handelt, es können Repräsentationsfehler auftreten. Angenommen, wir haben den folgenden Code:
<span><span><span class="hljs-variable">$number</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-title function_ invoke__">var_dump</span></span><span>(</span><span><span class="hljs-variable">$number</span></span><span>); </span><span><span class="hljs-comment">// Ausgabe float(0.30000000000000004)</span></span><span>
</span></span>Der obige Code zeigt den Darstellungsfehler der schwimmenden Punktzahlen. Obwohl wir erwarten, dass das Ergebnis 0,3 beträgt, beträgt das tatsächliche Ergebnis aufgrund der Genauigkeitsbeschränkung der Schwimmpunktzahlen 0,300000000000000000004 . Dieser Fehler ist besonders bei der Überprüfung großer Werte deutlich, da diese Fehler die Ergebnisse der Funktion is_double () beeinflussen können.
is_double () wird speziell zur Überprüfung der schwimmenden Punktzahlen verwendet, und in PHP ist der Float -Typ eine breite Palette von numerischen Typen. Um in großen numerischen Fällen den Missbrauch von is_double () zu vermeiden, können andere Typ -Check -Funktionen mit is_int () und is_numeric () kombiniert werden. Zum Beispiel:
<span><span><span class="hljs-variable">$number</span></span><span> = </span><span><span class="hljs-number">12345678901234567890</span></span><span>;
</span><span><span class="hljs-keyword">if</span></span><span> (</span><span><span class="hljs-title function_ invoke__">is_numeric</span></span><span>(</span><span><span class="hljs-variable">$number</span></span><span>)) {
</span><span><span class="hljs-keyword">if</span></span><span> (</span><span><span class="hljs-title function_ invoke__">is_int</span></span><span>(</span><span><span class="hljs-variable">$number</span></span><span>)) {
</span><span><span class="hljs-keyword">echo</span></span><span> </span><span><span class="hljs-string">"This is an integer.\n"</span></span><span>;
} </span><span><span class="hljs-keyword">elseif</span></span><span> (</span><span><span class="hljs-title function_ invoke__">is_double</span></span><span>(</span><span><span class="hljs-variable">$number</span></span><span>)) {
</span><span><span class="hljs-keyword">echo</span></span><span> </span><span><span class="hljs-string">"This is a double.\n"</span></span><span>;
}
}
</span></span>Durch Kombinieren von is_numeric () können Sie zuerst prüfen, ob die Variable eine gültige Nummer ist, und dann is_int () oder is_double () für ein weiteres Typ -Beurteilung nach Bedarf verwenden.
Für Szenarien, in denen sehr große Werte erforderlich sind, liefert PHP GMP-Erweiterungen für hochpräzise numerische Berechnungen. Mit der GMP -Erweiterung können Sie Ganzzahlen von willkürlicher Größe bewältigen, ohne Präzision zu verlieren, ohne sich über die Genauigkeit der schwimmenden Punkte zu sorgen.
Verwenden Sie beispielsweise GMP -Erweiterungen, um eine große Ganzzahl zu bewältigen:
<span><span><span class="hljs-variable">$bigNumber</span></span><span> = </span><span><span class="hljs-title function_ invoke__">gmp_init</span></span><span>(</span><span><span class="hljs-string">"123456789012345678901234567890"</span></span><span>);
</span><span><span class="hljs-title function_ invoke__">var_dump</span></span><span>(</span><span><span class="hljs-variable">$bigNumber</span></span><span>); </span><span><span class="hljs-comment">// Ausgabe一个 GMP Objekt</span></span><span>
</span></span>Mit der GMP-Erweiterung können Sie die Genauigkeit von PHP-integrierten Schwimmpunktzahlen vermeiden und hochpräzise numerische Berechnungen durchführen. Es ist zu beachten, dass IS_DOUBLE () nicht für numerische Werte des GMP -Typs gilt. In diesem Fall ist es erforderlich , IS_Resource () oder eine bestimmte GMP -Funktion zu verwenden, um den Typ der Variablen zu überprüfen.
is_double () kann in bestimmten Situationen irreführend sein. Aufgrund der Einschränkungen der Gleitkommagenauigkeit kann PHP möglicherweise nicht genau eine Ganzzahl von einer schwimmenden Punktzahl unterscheiden, insbesondere wenn die Zahlen sehr groß sind. Beispielsweise führt die Erkennung von is_double () im folgenden Code zu einem ungenauen Ergebnis:
<span><span><span class="hljs-variable">$largeInt</span></span><span> = </span><span><span class="hljs-number">12345678901234567890</span></span><span>;
</span><span><span class="hljs-keyword">echo</span></span><span> </span><span><span class="hljs-title function_ invoke__">is_double</span></span><span>(</span><span><span class="hljs-variable">$largeInt</span></span><span>) ? </span><span><span class="hljs-string">"Double\n"</span></span><span> : </span><span><span class="hljs-string">"Not Double\n"</span></span><span>; </span><span><span class="hljs-comment">// Ausgabe Not Double</span></span><span>
</span></span>In einigen Fällen kann $ largint zwar eine Ganzzahl fälschlicherweise als schwimmende Punktzahl verarbeiten, da sein Wert den Repräsentationsbereich der schwimmenden Punktgenauigkeit überschreitet, sodass das Ergebnis möglicherweise nicht wie erwartet ist.
Bei der Verwendung von PHPs is_double () -Funktion, insbesondere wenn es sich um große Werte handelt, müssen Sie vorsichtig mit den Genauigkeitsbeschränkungen der Gleitkomma-Zahlen vorsichtig sein. Die Funktion is_double () kann das Genauigkeitsproblem der schwimmenden Punktzahlen und der super großen Ganzzahlen nicht genau unterscheiden, insbesondere wenn große Werte in schwimmende Punktzahlen umgewandelt werden, kann der Genauigkeitsverlust auftreten. Um diese Art von Problemen zu vermeiden, können Sie andere Typ-Check-Funktionen in Verbindung mit ihnen verwenden oder in Betracht ziehen, GMP-Erweiterungen zu verwenden, um super große Zahlen zu verarbeiten. Durch das Verständnis dieser potenziellen Fallstricke können Entwickler die Programme mit großer Wert besser bewältigen.
