web-dev-qa-db-fra.com

Quelle est la différence entre ++ $ i et $ i ++ en PHP?

Quelle est la différence entre ++$i et $i++ en PHP?

phpoperators
65
Steven

++$i est pré-incrémenté, alors que $i++ est post-incrémenté.

  • pré-incrémentation: incrémente la variable i en premier, puis dé-référence.
  • post-incrémentation: déréférencer puis incrémenter i

"Profitez du fait que PHP Vous permet de post-incrémenter ($ i ++) Et de pré-incrémenter (++ $ i). La signification de Est la même tant que vous ne l’êtes pas écrire quelque chose comme $ j = $ i ++, Cependant, la pré-incrémentation est presque 10% plus rapide, ce qui signifie que vous devez passer de post-à-pré-incrémentation lorsque vous avez le opportunité, surtout dans les boucles serrées et surtout si vous êtes pédant sur micro-optimisations! " - TuxRadar

Pour plus de clarté, la post-incrémentation dans PHP a été documentée comme stockant une variable temporaire qui attribue cette surcharge de 10% par rapport à la pré-incrémentation.

78
jldupont

++$i est une pré-incrémentation

  1. $i est incrémenté
  2. la nouvelle valeur est retournée

$i++ est post-incrémentation

  1. la valeur de $i copiée dans une variable temporaire interne
  2. $i est incrémenté 
  3. la copie interne de l'ancienne valeur de $i est renvoyée
37
Gumbo

++$i incrémente $i, mais évalue à la valeur de $i+1$i++ incrémente $i, mais évalue à l'ancienne valeur de $i.

Voici un exemple:

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

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

Il y a parfois un léger coût de pré-performance pour utiliser $i++. Vous voyez, quand vous faites quelque chose comme

$a = $i++;

Tu fais vraiment ça:

$temporary_variable = $i;
$i=$i+1;
$a=$temporary_variable;
37
Shalom Craimer
++$i //first increment $i then run line
$i++ //first run line then increment $i
12
Sajad Bahmani

dans ce cas il n'y a pas de différence:

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

mais:

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

cet exemple elplains simplement

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

?>
5
Ashraful Alam

Différence est: ++$i incrémentera la variable $i et renverra la valeur mise à jour, alors que $i++ renverra la valeur d'origine, donc incrémentez-la.

$prefix = 1;
$postfix = 1;
echo ++$prefix;   // 2
echo $postfix++;  // 1
4
Rubens Farias

Une autre façon de regarder les incréments avant et après consiste à utiliser un raccourci pour combiner deux instructions.

Pré-incrémentation

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

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

Post-incrémentation

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

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

Pour expliquer le point de jldupont:

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

L’objet principal de l’opérateur d’incrément post-fix est l’utilisation suivante:

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

C’est une façon très élégante de contourner certaines itérations de tableaux. Panne:

  1. La variable $ quelque chose sera assigné à l’élément de tableau indexé avec $ i
  2. La variable $ i sera incrémentée
  3. L'itération est à la fin, condition sera vérifiée

Dans tous les autres cas, vous devez utiliser l'opérateur de préfixe. Cela rend le code beaucoup plus clair (vous pouvez être sûr que vous travaillez déjà avec la valeur incrémentée d'une variable particulière). 

3
user3554809

Réponse courte:

  • Le préfixe augmente la valeur et renvoie la valeur augmentée
  • Postfix augmente la valeur et renvoie la valeur avant qu'elle ne soit augmentée
  • Le préfixe est plus rapide

Réponse longue: Si vous y réfléchissez un peu, comment vous les implémenteriez vous-même, vous vous rendrez probablement compte que le préfixe pourquoi est plus rapide. À vrai dire, postfix est effectivement (souvent) implémenté using prefix:

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

Évitez postfix sauf si vous avez une raison spécifique de ne pas le faire. La différence de vitesse peut être considérable pour les types de données complexes.

En fait, j'ai examiné cela il y a quelques jours. Voici ma source.

1
Mizipzor

Il est probablement mieux illustré par un exemple ...

Post-incrémentation: 

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

Pré-incrémentation: 

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

J'ai exécuté le code suivant pour tester si ++ $ i est 10% plus rapide que $ i ++. J'avoue que le code n'a pas de résultat stable, mais j'aurais quand même dû au moins avoir vu des chiffres proches des 10%. Le maximum que j'ai eu était de 4-4,5% environ. 

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

Les deux opérateurs font toujours ce que leur syntaxe implique: incrémenter. Indépendamment du préfixe ou du suffixe, la variable est sûre d'être incrémentée de 1. La différence entre les deux réside dans leurs valeurs de retour.

1. L'incrément de préfixe renvoie la valeur d'une variable après son incrémentation.

2. D'autre part, l'incrément postfix plus communément utilisé retourne la valeur d'une variable avant qu'elle ne soit incrémentée.

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

Pour rappeler cette règle, je pense à la syntaxe des deux. Quand on tape l'incrément de préfixe, on dit ++ x. La position du ++ est importante ici. Dire ++ x signifie d'abord incrémenter (++) puis renvoyer la valeur de x, nous avons donc ++ x. L'incrément postfixe fonctionne à l'inverse. Dire x ++ signifie renvoyer la valeur de x d'abord, puis l'incrémenter (++) ensuite, ainsi x ++.

0
Rohit Saini