postincremento - ¿Cuál es la diferencia entre++ $ i y $ i++ en PHP?

operador decremento c

Question

¿Cuál es la diferencia entre ++$i y $i++ en PHP?

Answer 1

Ejecuté el siguiente código para probar si ++ $ i es un 10% más rápido que $ i ++. Lo admito, el código no tiene un resultado estable, pero incluso entonces debería haber visto algunos números cerca del 10%. Lo más alto que obtuve fue 4-4.5% aproximadamente.

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

Answer 2

El objetivo principal del operador de incremento posterior a la corrección es el uso de esta manera:

while(*condition*)
    $array[$i++] = $something;

Esta es una manera muy elegante de cómo evitar algunas iteraciones de matriz. Descompostura:

1. Se asignará $ algo variable al elemento de matriz indexado con $ i
2. La variable $ i se incrementará
3. La iteración es al final, se verificará la condición

En todos los demás casos, debe usar el operador de prefijo. Hace que el código sea mucho más claro (puede estar seguro de que ya trabaja con el valor incrementado de una variable particular).

Answer 3

Otra forma de ver el incremento previo y posterior es que es una combinación de dos instrucciones.

Pre-incremento

// long form
$y = $y + 1;
$x = $y; // any statement using $y

// shorthand
$x = ++$y; // the same statement using $y

Post-incremento

// long form
$x = $y; // any statement using $y
$y = $y + 1;

// shorthand
$x = $y++; // the same statement using $y

Answer 4

Para explicar el punto de Jldupont:

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

Answer 5

Probablemente sea mejor ilustrado por un ejemplo ...

Incremento posterior:

$zero = 0;
$n = $zero++; //$n is zero

Pre-incremento:

$zero = 0;
$n = ++$zero; //$n is one

Answer 6

en este caso, no hay diferencia

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

pero:

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

Answer 7

este ejemplo elplains simplemente

<?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

?>

Answer 8

++$i es pre-incremento

1. $i se incrementa
2. el nuevo valor es devuelto

$i++ es post-incremento

1. el valor de $i copiado en una variable temporal interna
2. $i se incrementa
3. se devuelve la copia interna del valor anterior de $i

Answer 9

++$i es preincremento, mientras que $i++ post-incremento.

• pre-incremento: incrementa la variable i primero y luego des-referencia.
• post-incremento: des-referencia y luego incrementar i

"Aproveche el hecho de que PHP le permite el incremento posterior ($ i ++) y el preincremento (++ $ i). El significado es el mismo siempre y cuando no esté escribiendo algo como $ j = $ i ++, sin embargo el pre-incremento es casi un 10% más rápido, lo que significa que debes cambiar de post-a-pre-incremento cuando tengas la oportunidad, especialmente en circuitos cerrados y especialmente si eres pedante sobre las micro-optimizaciones ". - TuxRadar

Para mayor aclaración, el post-incremento en PHP se ha documentado como el almacenamiento de una variable temporal que atribuye a este 10% de gastos generales frente a pre-incremento.

Answer 10

++$i incrementa $i , pero evalúa el valor de $i+1 $i++ incrementa $i , pero se evalúa con el valor anterior de $i .

Aquí hay un ejemplo:

$i = 10;
$a = $i++;
// Now $a is 10, and $i is 11

$i = 10;
$a = ++$i;
// Now $a is 11, and $i is 11

A veces hay un pequeño costo de rendimiento para usar $i++ . Mira, cuando haces algo como

$a = $i++;

Realmente estás haciendo esto:

$temporary_variable = $i;
$i=$i+1;
$a=$temporary_variable;

Answer 11

La diferencia es: ++$i incrementará la variable $i y devolverá el valor actualizado, mientras que $i++ devolverá el valor original, así que increméntelo.

$prefix = 1;
$postfix = 1;
echo ++$prefix;   // 2
echo $postfix++;  // 1

Answer 12

Respuesta corta:

• El prefijo aumenta el valor y devuelve el valor aumentado
• Postfix aumenta el valor y devuelve el valor antes de aumentar
• El prefijo es más rápido

Respuesta larga: si piensas un poco al respecto, cómo implementarías eso por ti mismo, probablemente te darás cuenta de por qué el prefijo es más rápido. A decir verdad, postfix en realidad (a menudo) se implementa usando el prefijo:

const T T::operator ++ (int) // postfix
    {
    T orig(*this);
    ++(*this); // call prefix operator
    return (orig);
    }

Evita postfix a menos que tengas una razón específica para no hacerlo. La diferencia de velocidad puede ser bastante grande para tipos de datos complejos.

De hecho, miré esto hace unos días. Aquí está mi fuente.

Answer 13

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