Was ist der Unterschied zwischen ++$i
und $i++
in PHP?
82
++$i
ist Pre-Inkrement während $i++
Post-Inkrement.
i
zuerst die Variable und dann die Referenz.i
"Nutzen Sie die Tatsache, dass Sie mit PHP nachträglich inkrementieren ($ i ++) und vorinkrementieren (++ $ i) können. Die Bedeutung ist dieselbe, solange Sie nichts wie $ j = $ i ++ schreiben Das Pre-Inkrementieren ist fast 10% schneller, was bedeutet, dass Sie von Post-Inkrementieren zu Pre-Inkrementieren wechseln sollten, wenn Sie die Möglichkeit dazu haben, insbesondere in engen Schleifen und besonders, wenn Sie sich für Mikrooptimierungen interessieren! " - TuxRadar
Zur weiteren Verdeutlichung wurde dokumentiert, dass die Nachinkrementierung in PHP eine temporäre Variable speichert, die diesem Overhead von 10% gegenüber der Vorinkrementierung zugeordnet ist.
++$i
Inkremente$i
, wird aber auf den Wert von$i+1
$i++
Inkrementen$i
ausgewertet, aber auf den alten Wert von$i
.Hier ist ein Beispiel:
$i = 10; $a = $i++; // Now $a is 10, and $i is 11 $i = 10; $a = ++$i; // Now $a is 11, and $i is 11
Es gibt manchmal leichte Leistungskosten für die Verwendung
$i++
. Sehen Sie, wenn Sie so etwas tunDu machst das wirklich:
$temporary_variable = $i; $i=$i+1; $a=$temporary_variable;
quelle
$a=func()++
und fragen Sie sich, wie Sie ihn ohne ++ und ohne mehrmaliges Aufrufen von func () neu schreiben können.++$i
ist Vorinkrementierung$i
wird erhöht$i++
ist Nachinkrementierung$i
in eine interne temporäre Variable kopiert$i
wird erhöht$i
wird zurückgegebenquelle
++$i //first increment $i then run line $i++ //first run line then increment $i
quelle
In diesem Fall gibt es keinen Unterschied:
for($i = 0;$i<3;++$i)var_dump $i; /* int(0) int(1) int(2) */ for($i = 0;$i<3;$i++)var_dump $i; /* int(0) int(1) int(2) */
aber:
for($i = 0;$i<3; $j = ++$i )var_dump($j); /* NULL int(1) int(2) */ for($i = 0;$i<3; $j = $i++ )var_dump($j); /* NULL int(0) int(1) */
quelle
Dieses Beispiel erklärt einfach
<?php $x = 10; echo $x++. ' '.$x; // the result is 10 and 11 echo '<br>'; $y = 10; echo ++$y. ' ' .$y; // the result is 11 and 11 // so the $x++ is not showing +1 at first but the next time // and the ++y is showing +1 first time but not increasing next
quelle
Der Unterschied besteht darin, dass
++$i
die$i
Variable erhöht und der aktualisierte Wert zurückgegeben wird, während$i++
der ursprüngliche Wert zurückgegeben wird. Erhöhen Sie ihn also.$prefix = 1; $postfix = 1; echo ++$prefix; // 2 echo $postfix++; // 1
quelle
Um den Punkt von jldupont zu erklären:
$i = 1; $x = $i++; echo $x; // prints 1 $x = ++$i; echo $x; // prints 3
quelle
Eine andere Art, das Inkrementieren vor und nach dem Inkrementieren zu betrachten, ist die Abkürzung für das Kombinieren von zwei Anweisungen.
Vorinkrementieren
// long form $y = $y + 1; $x = $y; // any statement using $y // shorthand $x = ++$y; // the same statement using $y
Nachinkrementierung
// long form $x = $y; // any statement using $y $y = $y + 1; // shorthand $x = $y++; // the same statement using $y
quelle
Es wird wahrscheinlich am besten durch ein Beispiel veranschaulicht ...
Nachinkrement:
$zero = 0; $n = $zero++; //$n is zero
Vorinkrement:
$zero = 0; $n = ++$zero; //$n is one
quelle
Kurze Antwort:
Lange Antwort: Wenn Sie ein wenig darüber nachdenken, wie Sie diese selbst implementieren würden, werden Sie wahrscheinlich erkennen, warum das Präfix schneller ist. Um ehrlich zu sein, wird Postfix tatsächlich (oft) mit dem Präfix implementiert :
const T T::operator ++ (int) // postfix { T orig(*this); ++(*this); // call prefix operator return (orig); }
Vermeiden Sie Postfix, es sei denn, Sie haben einen bestimmten Grund, dies nicht zu tun. Der Geschwindigkeitsunterschied kann bei komplexen Datentypen sehr groß sein.
Ich habe das tatsächlich vor ein paar Tagen nachgeschlagen. Hier ist meine Quelle.
quelle
Der Hauptzweck des Post-Fix-Inkrement-Operators ist die Verwendung wie folgt:
while(*condition*) $array[$i++] = $something;
Dies ist eine sehr elegante Methode, um einige Array-Iterationen zu umgehen. Nervenzusammenbruch:
In allen anderen Fällen sollten Sie den Präfixoperator verwenden. Dies macht den Code viel klarer (Sie können sicher sein, dass Sie bereits mit dem inkrementierten Wert einer bestimmten Variablen arbeiten).
quelle
$ i ++ wird als Post-Inkrement bezeichnet. Der Wert von $ i wird erst erhöht, nachdem zuerst $ j der ursprüngliche Wert von $ i zugewiesen wurde.
++ $ i wird als Pre-Inkrement bezeichnet. Es erhöht den Wert von $ i, bevor der Wert $ j zugewiesen wird, sodass der aktualisierte Wert von $ i $ j zugewiesen wird.
Daher,
$i = 4; $j = $i++; // Now, $i = 5 and $j = 4 $i = 4; $j = ++$i; // Now, $i = 5 and $j = 5
Diese Theorien gelten in ähnlicher Weise auch für die Dekrementierung.
Hoffe das hilft!
quelle
Ich habe den folgenden Code ausgeführt, um zu testen, ob ++ $ i 10% schneller als $ i ++ ist. Ich gebe zu, der Code hat kein stabiles Ergebnis, aber selbst dann hätte ich zumindest einige Zahlen in der Nähe der 10% sehen müssen. Der höchste Wert, den ich bekam, war ungefähr 4-4,5%.
<?php $randomFloat = rand(0, 10) / 10; $before1 = microtime(true); for($i=0; $i <1000000; ++$i){ $rand = (rand(0, 10) / 10) * (rand(0, 10) / 10); } $after1 = microtime(true); echo 'it took '.($after1-$before1) . ' seconds fot ++$i<br />'; $before2 = microtime(true); for($i=0; $i <1000000; $i++){ $rand = (rand(0, 10) / 10) * (rand(0, 10) / 10); } $after2 = microtime(true); echo 'it took '.($after2-$before2) . ' seconds fot $i++<br /><br />'; echo '++$i is '.((($after1-$before1)*100)/($after2-$before2)-100).'% faster than $i++';
quelle
Beide Operatoren tun immer noch, was ihre Syntax impliziert: Inkrementieren. Unabhängig von Präfix oder Postfix wird die Variable mit Sicherheit um 1 erhöht. Der Unterschied zwischen den beiden liegt in ihren Rückgabewerten.
1. Das Präfixinkrement gibt den Wert einer Variablen zurück, nachdem sie inkrementiert wurde.
2. Andererseits gibt das am häufigsten verwendete Postfix-Inkrement den Wert einer Variablen zurück, bevor sie inkrementiert wurde.
// Prefix increment let prefix = 1; console.log(++prefix); // 2 console.log(prefix); // 2 // Postfix increment let postfix = 1; console.log(postfix++); // 1 console.log(postfix); // 2
Um mich an diese Regel zu erinnern , denke ich über die Syntax der beiden nach. Wenn man das Präfixinkrement eingibt, sagt man ++ x. Die Position des ++ ist hier wichtig. ++ x zu sagen bedeutet, zuerst (++) zu erhöhen und dann den Wert von x zurückzugeben, also haben wir ++ x. Das Postfix-Inkrement funktioniert umgekehrt. X ++ zu sagen bedeutet, zuerst den Wert von x zurückzugeben und danach zu erhöhen (++), also x ++.
quelle