Q: Is this a javascript optimization? Is it faster to do
(obj = {})[key] = val;

then
obj = {}
obj[key] = val;

?
Or is this just being done because it's easier to read on one line? 

A: I doubt that the two code fragments have any difference in performance. Some people just like to code in a more compact way. I personally think the first example is horribly cryptic; even the author may need to stop and figure out what's going on when re-reading the code six months later.
"The competent programmer is fully aware of the limited size of his own skull. He therefore approaches his task with full humility, and avoids clever tricks like the plague." — Edsger W. Dijkstra

A: No, there's no real difference. It's probably obvious to most experienced coders but I made a jsperf to prove it : http://jsperf.com/tetetetee
You can't see any reproducible difference. If there is a difference, it will be, in any case, so small that you wouldn't reliably measure it.
The reason to use the first form is just that it's shorter to write and, for experienced JavaScript coders, maybe a little shorter to read too. In some cases it might help make the code more concise or symmetric. Personally I don't dislike the first form but I wouldn't recommend it as it would mostly make the code harder to read by most people.

A: I don't think there's any difference between 2 snippets, the second one is more readable compared to the first one.

A: The two do exactly the same thing. The single line version is something the compression/minifier would/should do internally versus a user doing it explicitly. Not very readable in my opinion.

A: In short: there is no functional difference, nor is there a difference in the way it's evaluated. The way it is evaluated is as follows:
obj = {}

A new object is created in memory and a reference is stored to a variable called obj.
Both putting parentheses around that assignment ((obj = {})...) and just calling the instance in the second example (obj...) directly references the same object in memory. The only difference is that the second code sample is written on a new line.
From there on the code is exactly the same: [key] = val, setting a property stored in the key variable to the value set in val.
This shows that the code is evaluated exactly the same, meaning there cannot be any difference in performance.
The two reasons I can think of why the first example is the way it is, is to make the code extra compact to reduce the file size, or it just being someone's personal preference.
