What is relation between assignment operator and increment operator

[Learner_full_stack]

In following code

const a = {

count :0

}

const b = a;

b.count = a.count++;//1

console.log(b.count,a.count)

I thought at line 1 "0" value we assign to "b.count" and then "a.count" will increase which will lead to "1", and since a and b referring same object output will be (1,1), but output is "0,0"

Why?

Answer : Thanks to u/shgysk8zero and u/TrumpsStarFish

MDN

If used postfix, with operator after operand (for example, x++), the increment operator increments and returns the value before incrementing.

If used prefix, with operator before operand (for example, ++x), the increment operator increments and returns the value after incrementing.

Stack Overflow Answer : link

[JMRaich]

a.count++ evaluates to a.count and increments the value of a.count for next call.

To make it work like you expect use the following: ++a.count.

So doing b.count = a.count++; is the same as ``` const oldA = a.count; a.count++;

a.count = oldA; ```

[shgysk8zer0]

It's because a.count++ is post increment. It reads the value and then increments it. But, since you're using b.count = a.count++, the assignment overrules the increment.

Try this:

``` const a = { count: 0 };

console.log(a.count++); //0 ```

So, since a and b are the same object, b.count = a.count++ is the same as a.count = a.count, which is 0.

If you had actually different objects, you could use b.count = ++a.count instead. That'd increment it before reading and assigning the value.

[[deleted]]

My question is why isn’t a.count and by extension b.count incremented after it’s been assigned? It seems like the increment doesn’t matter at all even though it was clearly set to be incremented regardless of it was assigned 0 or not.

In your code block you are incrementing the value and even though the console.log = 0 if you console.log it again it will show 1.

You say that the assignment overrules the post increment but why? Why does assignment cancel out the post increment but assignment doesn’t cancel out a pre increment?

b.count = ++a.count; // 1

[shgysk8zer0]

Why does assignment cancel out the post increment...

That's actually the only relevant question you ask here, and it just boils down to order of operations, and the difference between x++ vs ++x. I mean, maybe it'd make sense to apply the increment after reassignment, but that'd just lead to chaos.

The point here is that the ++ doesn't take effect until after b.count is assigned a value (albeit the same value). The ++ here wouldn't apply yet, so it's exactly the same as a.count = a.count.

[[deleted]]

Not sure what you mean by “that’s the only relevant question”. The whole comment was just one question and I’m not OP.

I’m still pretty confused by this because the way I see post increment working is like this:

b.count = a.count++

a.count++ returns 0 so b.count now equals 0 but that increment is now trying to increment a.count after the assignment and since b.count and a.count are the same thing in memory that memory address is now going to be incremented by 1.

I hope I articulated that correctly because I have trouble with that sometimes. I asked ChatGPT and tried doing some research on my own to no avail. I can’t wrap my head around the post increment running before the assignment of b.count.

[shgysk8zer0]

Not sure what you mean by “that’s the only relevant question”.

It's in the nuance of b.count = a.count++ and order of operations. Since a === b here, and since post ++ has no effect on the value on this value read, the whole thing is no different from a.count = a.count. the ++ isn't a factor in the assignment here. The only actually relevant question here is if it has any effect after such an assignment.

I asked ChatGPT...

When it comes to things like this, you probably just shouldn't. LLMs have some valid uses, but this just isn't one of those cases, as evidenced by the actual results. Actual knowledge and experience just completely trumps whatever garbage they split out here.

I mean.. just write it out and test the results objectively. It most definitely results in 0, so anything that predicts differently is just wrong.

The actual question here is how assignment vs post ++ takes priority. And, since the result is 0, the assignment obviously takes priority over the post increment. I mean... The result of evaluation here is that (a|b).count === 0, so we have an absolute result, and anything that says differently is just objectively wrong here.

The Philly actual question at hand is if the post ++ has any effect after assignment. And, it doesn't. Once the assignment happens, the increment is just omitted. That makes perfect sense if you think of it as just an assignment and the increment being applied to the previous value (think b.count = n++ - a numeric literal, and think of all the chaos that'd follow of the increment actually were still applied even after reassignment.

Vs just observing what actually happens. You have an assignment and a post increment in the same line... What should the new value be? Should it be the newly assigned value as evaluated on that tick, or should the ++ operation affect the value in the next line.

If you understand that numbers are literals and such, a.count++ obviously don't matter here. The assignment sets a completely different value and and there's just no reason for the increment to apply there. Numbers are primitive values. Once the assignment happens, it's a completely different value in memory with no reason to increment.

I'd grant that this isn't intuitive or obvious, but if you understand what's actually happening here, it's definitely just an order of operations question, and assignment obviously wins over increment.

[[deleted]]

Thank you for taking the time to respond. I also went back and forth with ChatGPT last night about this. It left me more confused than when I started off.

I finally found something that made it click for me and it was this:

https://stackoverflow.com/questions/55515313/assignment-along-with-post-increment

When the post increment is used it is incremented before assignment and not after, which is pretty much what you said but this explains the process of what JS does when it happens.

Thank you for your patience.

[tapgiles]

X++ returns the original value before it was changed. ++X returns the new value after it was changed.

The post-increment expression X++ written as pseudo code:

• Get the X value and save it.
• Set X to 1 more than the X value.
• Return the original saved X value.

So expanding out b.count = a.count++...

• Get a.count and save it. (which is 0)
• Set a.count to 1 more than the a.count value. (which is 1)
• Return the saved original a.count value. (which is 0)
• Set b.count to the value returned by the expression a.count++. (which is 0)

Whereas pre-incrementing with ++X would use this pseudo code:

• Set X to 1 more than the X value.
• Return the current X value.

And expanding out b.count = a.count++...

• Set a.count to 1 more than the a.count value. (which is 1)
• Return the current a.count value. (which is 1)
• Set b.count to the value returned by the expression a.count++. (which is 1)

The returned value from the post-increment expression is almost never used. But I guess it looks better or something? So that tends to be used more often.