2010-08-12 4 views
86

En Javascript puede usar el operador ++ antes o después del nombre de la variable. ¿Cuáles son, si las hay, las diferencias entre estas formas de incrementar una variable?++ someVariable vs. someVariable ++ en Javascript

+0

Ver también el lenguaje-agnóstico [Diferencia entre i ++ y ++ i en un bucle?] (Http://stackoverflow.com/q/484462/1048572) – Bergi

Respuesta

145

Igual que en otros idiomas:

  • ++x (pre-incremento) significa "incrementar la variable; el valor de la expresión es el valor final"
  • x++ (post-incremento) significa "recordar el valor original, y luego incrementar la variable; el valor de la expresión es el valor original"

Ahora cuando se utiliza como una declaración independiente, que significan la misma cosa:

x++; 
++x; 

La diferencia se produce cuando utiliza el valor de la expresión en otro lugar. Por ejemplo:

x = 0; 
y = array[x++]; // This will get array[0] 

x = 0; 
y = array[++x]; // This will get array[1] 
+4

Curses , Casi te gano a una respuesta si no me hubiera detenido a cargar una respuesta práctica jsfiddle. ;-) – Chris

+2

¿Cómo se vería si usas '+ 1' en lugar de' ++'? ¿Hay alguna forma de incrementar antes o después al agregar números? – Keavon

+0

Me gustaría saber por qué si haces esta operación const r1 = (x ++) + (x ++); no produce el resultado esperado de acuerdo con su ejemplo. –

6

Como yo los entiendo si se utilizan autónomos que hacen lo mismo. Si intenta mostrar el resultado de ellos como una expresión, entonces pueden diferir. Pruebe la alerta (i ++) en comparación con la alerta (++ i) para ver la diferencia. i ++ evalúa i antes de la adición y ++ i hace la adición antes de evaluar.

Consulte http://jsfiddle.net/xaDC4/ para ver un ejemplo.

20
  • ++x incrementa el valor, luego lo evalúa y almacena.
  • x++ evalúa el valor, luego lo incrementa y lo almacena.
var n = 0, m = 0; 

alert(n++); /* Shows 0, then stores n = 1 */ 
alert(++m); /* Shows 1, then stores m = 1 */ 

Tenga en cuenta que hay ligeras ventajas de rendimiento en el uso de ++x siempre que sea posible, debido a que lea la variable, modificarlo, a continuación, evaluar y almacenarlo. Frente al operador x++ donde lee el valor, lo evalúa, lo modifica y luego lo almacena.

1

Estaba pensando en esto ayer leyendo this response a la pregunta sobre bad assumptions in C/C++. En todos los casos, ¿podemos garantizar que JavaScript se comporte de esta manera? ¿O crees que es una mala práctica usar la declaración de incremento dentro de una declaración más compleja?

+1

En cuanto a ECMA-262, parece razonablemente bien especificado. –

0
var x = 0, y = 0; 

//post-increment: i++ returns value then adds one to it 
console.log('x++ will log: ', x++); //0 
console.log('x after x++ : ', x); //1 

//pre-increment: adds one to the value, then returns it 
console.log('++y will log: ', ++y); //1 
console.log('y after ++y : ', y); //1 
0
var a = 1; 
var b = ++a; 
alert('a:' + a + ';b:' + b); //a:2;b:2 

var c = 1; 
var d = c++; 
alert('c:' + c + ';d:' + d); //c:2;d:1 

jsfiddle