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

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

++$ies preincremento mientras que $i++posincremento.

• preincremento: iprimero incrementa la variable y luego elimina la referencia.
• post-incremento: eliminar la referencia y luego incrementar i

"Aproveche el hecho de que PHP le permite post-incremento ($ i ++) y pre-incremento (++ $ i). El significado es el mismo siempre que no escriba nada como $ j = $ i ++, sin embargo el preincremento es casi un 10% más rápido, lo que significa que debe cambiar de post-incremento a preincremento cuando tenga la oportunidad, especialmente en bucles estrechos y especialmente si es pedante con las microoptimizaciones ". - TuxRadar

Para mayor aclaración, se ha documentado que el incremento posterior en PHP almacena una variable temporal que se atribuye a este 10% de sobrecarga frente al incremento previo.

++$iincrementa $i, pero evalúa el valor de $i+1 $i++incrementos $i, pero evalúa el valor anterior de $i.

He aquí 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, el uso conlleva un ligero coste de rendimiento $i++. Mira, cuando haces algo como

$a = $i++;

Realmente estás haciendo esto:

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

++$i es pre-incremento

1. $i se incrementa
2. se devuelve el nuevo valor

$i++ es post-incremento

1. el valor de $icopiado a una variable temporal interna
2. $i se incrementa
3. $ise devuelve la copia interna del antiguo valor de

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

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

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

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

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

Para explicar el punto de jldupont:

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

Otra forma de ver el incremento previo y posterior es que es una forma abreviada de combinar 2 declaraciones.

Preincremento

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

Probablemente esté mejor ilustrado con un ejemplo ...

Post-incremento:

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

Pre-incremento:

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

Respuesta corta:

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

Respuesta larga: si piensa un poco sobre cómo los implementaría usted mismo, probablemente se dará cuenta de por qué el prefijo es más rápido. A decir verdad, postfix se implementa (a menudo) usando prefijo:

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

Evite el sufijo a menos que tenga una razón específica para no hacerlo. La diferencia de velocidad puede ser considerable para tipos de datos complejos.

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

El propósito principal del operador de incremento posterior a la corrección es un uso como este:

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

Esta es una forma muy elegante de cómo sortear algunas iteraciones de matriz. Descompostura:

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

En todos los demás casos, debe utilizar 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 en particular).

$ i ++ se conoce como post-incremento. Incrementa el valor de $ i solo después de asignar primero el valor original de $ i a $ j.

++ $ i se conoce como preincremento. Incrementa el valor de $ i antes de asignar el valor a $ j, por lo que el valor actualizado de $ i se asignará a $ j.

Por lo tanto,

$i = 4;
$j = $i++;
// Now, $i = 5 and $j = 4

$i = 4;
$j = ++$i;
// Now, $i = 5 and $j = 5

Estas teorías se aplican de manera similar para decrementar también.

¡Espero que esto ayude!

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 al menos algunos números cercanos al 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++';

Ambos operadores siguen haciendo lo que implica su sintaxis: incrementar. Independientemente del prefijo o sufijo, la variable seguramente se incrementará en 1. La diferencia entre los dos radica en sus valores de retorno.

1. El incremento de prefijo devuelve el valor de una variable después de que se haya incrementado.

2. Por otro lado, el incremento de sufijo más comúnmente utilizado devuelve el valor de una variable antes de que se haya incrementado.

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

Para recordar esta regla , pienso en la sintaxis de los dos. Cuando se escribe el incremento de prefijo, se dice ++ x. La posición del ++ es importante aquí. Decir ++ x significa incrementar (++) primero y luego devolver el valor de x, entonces tenemos ++ x. El incremento de sufijo funciona a la inversa. Decir x ++ significa devolver el valor de x primero y luego incrementarlo (++) después, por lo tanto x ++.