Basically, the Logical AND operator (&&
), will return the value of the second operand if the first is truthy, and it will return the value of the first operand if it is by itself falsy, for example:
true && "foo"; // "foo"
NaN && "anything"; // NaN
0 && "anything"; // 0
Note that falsy values are those that coerce to false
when used in boolean context, they are null
, undefined
, 0
, NaN
, an empty string, and of course false
, anything else coerces to true
.
I think (not sure, although this is counter-intuitive) you can imagine:
a += (b += (a += b));
being written as:
a = a + (b += (a += b));
Although the plus +
operator has right to left associativity, JavaScript expressions are evaluated from left-to-right, so a
is evaluated first which is 9
now, then (b += (a += b))
is evaluated to 13
.
Now the +
operator adds from right-to-left, thus adding 13
to 9
and giving us 22
.
EDIT: I am not gonna comment directly on your questions because I feel confused by reading them :).
Instead I am gonna try to explain this differently. I think the main source of your confusion comes from the difference between operator precedence, associativity and order of evaluation.
I really advise you to read the part on the Order of Evaluation (4.7.7 in the book, which is a great book by the way).
Let's go with an example first:
var x =1, y = 2, z = 3;
var alpha = (z=4) + y * z;
console.log(x); // 1
console.log(y); // 2
console.log(z); // 4
console.log(alpha); // 12
In this example, although the multiplication operator *
has higher precedence than the summation operator +
, the the evaluation of the different components of the entire expression is still from left-to-right.
alpha
on the left is declared and created first, then (z=4)
is evaluated, then y
is evaluated to 2
. Now z
is evaluated again which results in 4
, notice that this is the new value which is caused by the side-effect of assigning 4
to z
earlier in the expression, remember (z=4)
.
This results in an overall value for alpha
that is equal to 12
.
Now back to our original expression:
a += (b += (a += b));
a
on the left is evaluated first which is 9
now, then the first b
to the left is evaluated which is now 2
, now the second a
is evaluated which is 9
also, then the last b
to the right is evaluated which is again 2
.
Now starts the real work, because of the parentheses the last (a += b)
is evaluated so now we have a = 11
, then (b += (a += b))
is evaluated which is now 13
, now this value is summed the value already evaluated which is 9 resulting in 22
.
If it hasn't happened this way, this would mean that a
on the left side of =
would have been evaluated twice which is not the case.
Summary: You can't update the value of an already evaluated expression.
I hope this can clear this for you, if you have any further questions then feel free to ask :)
Best Answer
It has nothing to do with the
if
statement, but:Here the last one,
(b=8)
, actually returns 8 as assigning always returns the assigned value, so it's the same as writingAnd
2 && 8
returns8
, as 2 is truthy, so it's the same as writinga = 8
.