ternario - operadores logicos javascript w3schools
Operadores unarios “++” y “-” situación extraña (5)
Aquí hay una situación de prueba para usar el operador unario "++":
var j = 0 ;
console.log(j);
j = j++;
console.log(j);
Para esto, la salida es:
0
0
Dado que la posición del operador ++ está en la parte posterior del operando, por lo que su precedencia es menor que la precedencia de la asignación, esperaría que "j" primero reciba el valor de sí mismo (es decir, 0), pero luego se incremente. Entonces, ¿por qué la segunda llamada de console.log(j) sigue mostrando "0"?
Solo para ser claros, sé que las soluciones son:
// 1)
j++;
// 2)
++j;
// 3)
j += 1;
// 4)
j = ++j;
¡Pero necesito saber por qué el paso de incremento no se realiza en este escenario específico, NO cómo solucionarlo!
De acuerdo con las http://www.ecma-international.org/ecma-262/5.1/#sec-11.3.1 la http://www.ecma-international.org/ecma-262/5.1/#sec-11.3.1 ,
- Sea lhs el resultado de evaluar LeftHandSideExpression.
- Lanzar una excepción SyntaxError si las siguientes condiciones son verdaderas:
- Tipo (lhs) es referencia es verdadera
- IsStrictReference (lhs) es verdadero
- Type (GetBase (lhs)) es un registro de entorno
- GetReferencedName (lhs) es "eval" o "argumentos"
- Deje que oldValue sea ToNumber (GetValue (lhs)).
- Deje que newValue sea el resultado de agregar el valor 1 a oldValue, utilizando las mismas reglas que para el operador + (consulte 11.6.3).
- Llame a PutValue (lhs, newValue).
- Vuelve el antiguo valor.
Por lo tanto, está claro que el nuevo valor se establece primero en lhs (en este caso j ) y el valor antiguo se devuelve como resultado de la expresión, que nuevamente se restablece en j . Por lo tanto, el valor no cambia.
Donde el ++ es le permite saber qué valor obtendrá de él en ese momento
++j; // increment the value and then give it to me.
j++; // give me the value and then increment it.
por lo que estabas diciendo
j = j++;
establezca j al valor de j antes de que se incremente.
Este es un comportamiento no intuitivo (¡pero no "extraño"!) Cuando se usa después del incremento.
La declaración j = j++ hace esto:
- Evaluar el LHS
- En este caso, no ocurre nada especial porque simplemente nombraste una variable, pero esto no siempre es así, por ejemplo,
foo() = j++
- En este caso, no ocurre nada especial porque simplemente nombraste una variable, pero esto no siempre es así, por ejemplo,
- Evaluar el RHS
- Tome el valor actual de
j(0), y recuérdelo como el resultado; - Incremento
j(para obtener 1);
- Tome el valor actual de
- Asignar el RHS a la LHS
- recuerde que RHS evalúa ese valor "recordado" de
j(0).
- recuerde que RHS evalúa ese valor "recordado" de
El resultado es un no-op.
La clave aquí es que se evalúa todo el RHS y se realiza el post-incremento, antes de la asignación final.
http://www.ecma-international.org/ecma-262/5.1/#sec-11.3.1
http://www.ecma-international.org/ecma-262/5.1/#sec-11.13.1
j ++ significa en la primera asignación, luego incrementa
++ j significa al primer incremento, luego asigna
Asi que,
var j = 0 ;
console.log(j);
j = ++j;
console.log(j);
0
1
j = j++ significa asignar el valor RHS primero a LHS y luego aumentar RHS en 1. Por otro lado, j = ++j significa incrementar RHS en 1 y luego asignarlo a LHS