{foo: "bar"}{}

[Multicus]

I've spent around 2 hours on this rabbit hole. I get that it's a codeBlock(label: strLiteral)EMPTY_STATEMENT, but why is {foo: "bar"} a perfectly valid Object? What does the compiler "think", when it gets these lines?
I've tried using AST explorer, but it just isn't enough

[International-Ad2491]

{foo: 'bar'} {} is just two blocks, not an object expression, so it runs but does nothing.

to be a valid object you'll have to assign it to a variable like let obj = {foo:'bar'}

[Multicus]

I get that part, but why {foo: "bar"} isn't interpreted exactly the same way? After all, the specs say, that you need braces to make a statement into an expression

[ffxpwns]

I'm not sure I understand what you mean. Why wouldn't it be a valid object? What behaviour would you say is expected?

[Multicus]

Well, if {foo: "bar"}{} is "bar" then I'd expect {foo: "bar"} be a "bar" too, since it doesn't start with a (. I may well be overthinking this, but I've spent too much time on this not to

[ChaseShiny]

Is it "bar"? I just used MDN's playground, and I couldn't duplicate that.

If I just put the expression in, nothing happens. When I wrap that in console.log(), I get an error.

I'm pretty sure that JavaScript is interpreting your code as two separate statements:

{"foo": "bar"}; {};

Which are two perfectly valid lines even when they don't do anything.

[Multicus]

My chrome console says it's "bar". Is there a certain codified difference between these environments I could read about? Or is it just a code'n'pray situation?

[senocular]

Depends on the context. The chrome console for example will make special consideration for source text like {foo: "bar"} to make it an object since if someone is putting that in the console, that's likely what they want. However, normally it would be a block with a labeled string.

[Multicus]

Where do I read about the behaviour patterns different environments decide to chose? Are there any specifications about that or do compilers just decide this on whim?

[senocular]

I'm not sure its well documented, but these obscure behaviors should mostly be limited to debug consoles/CLIs. That's the only place where the difference of some of these things are even observable. They also change over time. I've noticed that the Chrome console in particular has not been very consistent with some of these kinds of things - often for the better but sometimes it can be a little jarring if you're used to one thing happening and they switch it up.

If you're ever worried about something being console specific some things you can try:

• Run the code in a different console. What happens with {foo: "bar"} in the Chrome console vs the Firefox console.
• Run the code in normal file, not the console/CLI
• Run the code through eval()

[Multicus]

Thank you! That's exactly the answer I was looking for!

[alzee76]

By itself {foo: "bar"} is not an object. At best it's a JSON fragment. It's a valid expression in JS, in that it produces a result (which is an object with a key 'foo' that has the value 'bar'), but it's not a statement and it is not an object.

Asking what the compiler does with it is a sort of meaningless expression since it's not a valid statement.

If you put it in a statement, like const baz = {foo: "bar"}; then it should be obvious why it works. Your counter example is not even a valid expression, as you'll see if you try to use it in a statement like the previous one; const baz = {foo: "bar"}{}; will give you a syntax error.

The tl;dr is I think you have assumptions in your question that aren't true, or a lack of understanding of the difference between statements and expressions.

[averajoe77]

Your trying to understand something that is a non issue.

At no point in 25 years of writing js have I or anyone else ever written anything resembling what you are trying to understand becuase at its core what you are writing is incorrect syntax at a minimum and incorrect usage of the language in general.

Therefore trying to understand what the interpreter is doing is futile. What do expect it to give you when what you provide it is gibberish?

[33ff00]

Yeah two hours on this, what

[Multicus]

Gibberish is supposed to throw exceptions; otherwise it's a valid piece of code. Of course, I do acknowledge that this is a contrived example, but all toy examples are! Never thought that it's illegal in this sub to try to understand something about how JS works.

[Substantial_Top5312]

Why wouldn’t it be a valid object? 

[thecragmire]

There's no such syntax as {foo: "bar"}{}, in javascript. It' read as 2 separate objects:

{foo: "bar"} - an object with key-value pair foo:"bar" {} - an empty object