Warum ist === schneller als == in PHP?

Warum ist ===schneller als ==in PHP?

Da der Gleichheitsoperator ==den Datentyp vorübergehend erzwingt oder konvertiert, um festzustellen, ob er dem anderen Operanden entspricht, während ===(der Identitätsoperator) keinerlei Konvertierung durchführen muss und somit weniger Arbeit erledigt wird, was ihn schneller macht.

===führt keine Typumwandlung durch, 0 == '0'wertet also aus true, aber 0 === '0'- bis false.

Zuerst prüft ===, ob die beiden Argumente vom gleichen Typ sind. Daher schlagen die Nummer 1 und die Zeichenfolge '1' bei der Typprüfung fehl, bevor tatsächlich Vergleiche durchgeführt werden. Auf der anderen Seite überprüft == nicht zuerst den Typ und konvertiert beide Argumente in denselben Typ und führt dann den Vergleich durch.

Daher kann === einen Fehlerzustand schneller überprüfen

Es gibt zwei Dinge zu beachten:

1. Wenn Operandentypen unterscheiden sich dann ==und ===erzeugen unterschiedliche Ergebnisse . In diesem Fall spielt die Geschwindigkeit der Bediener keine Rolle. Was zählt, ist, welches das gewünschte Ergebnis liefert.

2. Wenn Operandentypen gleich sind, können Sie einen ==oder ===beide verwenden, um dieselben Ergebnisse zu erzielen . In diesem Fall ist die Geschwindigkeit beider Bediener nahezu identisch. Dies liegt daran, dass keiner der Operatoren eine Typkonvertierung durchführt.

Ich verglich die Geschwindigkeit von:

• $a == $b vs. $a === $b
• wo $aund $bwaren zufällige ganze Zahlen [1, 100]
• Die beiden Variablen wurden millionenfach generiert und verglichen
• Die Tests wurden 10 Mal durchgeführt

Und hier sind die Ergebnisse:

 $a == $b $a === $b
--------- ---------
 0.765770  0.762020
 0.753041  0.825965
 0.770631  0.783696
 0.787824  0.781129
 0.757506  0.796142
 0.773537  0.796734
 0.768171  0.767894
 0.747850  0.777244
 0.836462  0.826406
 0.759361  0.773971
--------- ---------
 0.772015  0.789120

Sie können sehen, dass die Geschwindigkeit fast identisch ist.

Ich weiß nicht wirklich, ob es wesentlich schneller ist, aber === ist in den meisten Sprachen ein direkter Typvergleich, während == versucht, bei Bedarf / möglich Typenzwang zu üben, um eine Übereinstimmung zu erzielen.

Das == verursacht vor dem Vergleich einen größeren Aufwand für die Typkonvertierung. === überprüft zuerst den Typ und fährt dann fort, ohne dass eine Typkonvertierung durchgeführt werden muss.

Weil === die Operanden nicht gezwungen werden müssen, vom gleichen Typ zu sein, bevor sie verglichen werden.

Ich bezweifle jedoch, dass der Geschwindigkeitsunterschied sehr groß ist. Unter normalen Umständen sollten Sie den sinnvolleren Operator verwenden.

Zusammenfassend lässt sich sagen, dass === schneller ist, da der Datentyp nicht konvertiert wird, um festzustellen, ob zwei Variablen denselben Wert haben. Wenn Sie jedoch feststellen müssen, ob zwei Variablen denselben Wert haben, verwenden Sie ==, wenn nicht festgelegt ist, welcher Typ Variablen sind , oder === wenn wichtig ist auch die Art der Variablen.

Schneller sollte nicht nur in der direkten Ausführungszeit gemessen werden (direkte Leistungstests sind in diesem Fall nahezu vernachlässigbar). Das heißt, ich müsste einen Test mit Iteration oder Rekursion sehen, um wirklich zu sehen, ob es einen signifikanten kumulativen Unterschied gibt (wenn er in einem realistischen Kontext verwendet wird). Die Test- und Debugging-Zeit, die Sie beim Umgang mit Edge-Fällen sparen, sollte auch für Sie von Bedeutung sein

In PHP (C-Code) ist der Wert eine "Klasse" wie:

class value
{
    $int_;
    $float_;
    $string_;
    $array_;
    $object_;
}

Wenn Ihr vergleichen $a == $bund $aist intArt, wird es wie etwas sein:

if ($a->int_ == $b->int_ || $a->int_ == (int) $b->float_ || $a->int_ == (int) $b->string_ || ...)

wird aber string '1'nicht in ASCII-Code umgewandelt 49, sondern 1.

Wenn Sie vergleichen $a === $bund $aist intArt, wird es wie some sein:

if ($a->int_ == $b->int_)

Wenn die Testergebnisse korrekt sind, muss es sich um ein Compilerproblem handeln.

Der Prozessor wird in einem Taktzyklus alles tun, was ihm gesagt wird

Wenn es weniger zu tun hat, ist es schneller zu tun

Zusatz:

Na ja, wenn der Compiler bereits eine Menge zu verarbeitenden Maschinencodes erstellt hat und dann bereits zig Millionen Dinge hinzugefügt hat, um zu bewältigen, welche Art von Daten verglichen werden müssen, ändert das Entfernen einer "kleinen" IF die Geschwindigkeit nicht wesentlich überhaupt.

Wenn jemand dies noch liest, bin ich an weiteren Diskussionen interessiert.

Phil