That's essentially it. What you have there is a compound assignment. The result of an assignment expression is the value being assigned, and so that value can be the right-hand side of another assignment expression.
But there's actually something else that happens before any of that: The variable user gets defined in the current context. Here's a detailled order of operation:
Upon entry to the context, the variable user is defined with the value undefined. This happens before any step-by-step code in the context happens.
When the execution cursor reaches that code in the step-by-step execution of code, then:
The property params is looked up on the variable req.
The property name is looked up on the result of req.params.
The property with the name defined by that value (the value of req.params.name) is retrieved from the object (presumably) referenced by the users variable.
The resulting value is assigned to the user property on req.
The same value is assigned to the user variable.
(I skipped a couple of bookkeeping steps to avoid overdoing the predantry.)
It's important to note that between steps 2.4 and 2.5 above, the value of req.user is not read from the req.user property. The value is determined in 2.3 and then used in 2.4 and again in 2.5. That is, a = b = c; is not the same as b = c; a = b;. The difference is that in the latter, the value is retrieved from b in the second assignment; in the former, it isn't, it's just reused from the b = c part. Now, when it's a simple property, that distinction doesn't particularly matter, but it does if you're using property accessor functions (either the non-standard kind from Mozilla's earlier variant of JavaScript, or the newly-standard kind from ECMAScript5). Live Example of the difference | Source
