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

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

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

++$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;

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

++$i //first increment $i then run line
$i++ //first run line then increment $i 

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)
*/

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

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

Um den Punkt von jldupont zu erklären:

$i = 1;
$x = $i++;
echo $x; // prints 1
$x = ++$i;
echo $x; // prints 3

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

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

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.

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

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

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++';

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