Was ist der Unterschied zwischen ++ $ i und $ i ++ in PHP?

82

Was ist der Unterschied zwischen ++$iund $i++in PHP?

Steven
quelle

Antworten:

96

++$iist Pre-Inkrement während $i++Post-Inkrement.

  • Pre-Inkrement: Inkrementieren Sie izuerst die Variable und dann die Referenz.
  • Nachinkrementierung: Referenzierung aufheben und dann inkrementieren 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.

jldupont
quelle
6
Ist dies eine allgemeine Faustregel oder ist es PHP-spezifisch?
Zoidberg
1
... die Quelle ist in meiner Antwort aufgeführt. Ich habe es selbst nicht überprüft ... Ich denke, ich könnte es tun, indem ich mir den Quellcode für PHP
ansehe
3
Ich würde mich nicht auf eine andere Sprache verallgemeinern.
Jldupont
3
Die Geschwindigkeitssteigerung der Vorinkrementierung ist PHP-spezifisch, da nach der Inkrementierung eine temporäre Variable erstellt wird, wodurch Overhead entsteht.
Corey Ballou
4
@knittl Denken Sie daran, dass es 10% einer (man hofft) sehr schnellen Operation ist :)
Jensgram
66

++$iInkremente $i, wird aber auf den Wert von $i+1 $i++Inkrementen $iausgewertet, 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 tun

$a = $i++;

Du machst das wirklich:

$temporary_variable = $i;
$i=$i+1;
$a=$temporary_variable;
Shalom Craimer
quelle
3
Dies ist die bessere Antwort. Eine generische Verallgemeinerung dessen, was dies ohne Codebeispiele tut, ist sinnlos. Die positiven Stimmen zu solchen Antworten stammen wahrscheinlich von denen, die bereits wissen, wie es funktioniert, und daher denken, dass sie großartige Antworten sind.
James
Ich bin mir sicher, dass es auf einer niedrigeren Ebene mehr gibt, daher könnte diese Frage strittig sein. Aber warum sollte PHP die temporäre Variable benötigen? Warum nicht: $ a = $ i; $ i = $ i + 1;
Taylor Vance
@ Taylor, das ist eine gute Frage! Versuchen Sie, $ i durch einen Funktionsaufruf wie diesen zu ersetzen: $a=func()++und fragen Sie sich, wie Sie ihn ohne ++ und ohne mehrmaliges Aufrufen von func () neu schreiben können.
Shalom Craimer
43

++$i ist Vorinkrementierung

  1. $i wird erhöht
  2. Der neue Wert wird zurückgegeben

$i++ ist Nachinkrementierung

  1. Der Wert von $iin eine interne temporäre Variable kopiert
  2. $i wird erhöht
  3. Die interne Kopie des alten Werts von $iwird zurückgegeben
Gumbo
quelle
14
++$i //first increment $i then run line
$i++ //first run line then increment $i 
Sajad Bahmani
quelle
Das ist technisch eine übermäßige Vereinfachung - denken Sie an eine for-Schleife usw.
Antony Carthy
11

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)
*/
0b10011
quelle
Dies ist nützlich, das Präfix-Inkrement scheint die geringste Überraschung zu haben. Ich werde jetzt immer das Präfix-Inkrement verwenden.
CMCDragonkai
8

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
Ashraful Alam
quelle
Vielen Dank für das einfache Beispiel. Ich verstehe jetzt.
Praditha
7

Der Unterschied besteht darin, dass ++$idie $iVariable 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
Rubens Farias
quelle
5

Um den Punkt von jldupont zu erklären:

$i = 1;
$x = $i++;
echo $x; // prints 1
$x = ++$i;
echo $x; // prints 3
Boldewyn
quelle
4

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
Michael
quelle
3

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
Brianreavis
quelle
3

Kurze Antwort:

  • Das Präfix erhöht den Wert und gibt den erhöhten Wert zurück
  • Postfix erhöht den Wert und gibt den Wert zurück, bevor er erhöht wurde
  • Präfix ist schneller

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.

Mizipzor
quelle
3

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:

  1. Die Variable $ etwas wird dem mit $ i indizierten Array-Element zugewiesen
  2. Die Variable $ i wird inkrementiert
  3. Iteration ist am Ende, Zustand wird überprüft

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).

user3554809
quelle
Upvoted für die Empfehlung, ein Präfix zu verwenden, es sei denn, ein Postfix wird unbedingt benötigt.
Developerbmw
3

$ 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!

Tharinda Nimnajith
quelle
0

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++';
Wachsflachs
quelle
-1

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 ++.

Rohit Saini
quelle