in JSON, Why is each name quoted?

Both : and whitespace are permitted in identifiers. Without the quotes, this would cause ambiguity when trying to determine what exactly constitutes the identifier.

Question 1: why not allow the name in the name/value pairs to be unquoted identifiers?

The design philosophy of JSON is "Keep it simple"

"Quote names with "" is a lot simpler than "You may quote names with " or ABC2 but you don't have to, unless they contain certain characters (or combinations of characters that would make it a keyword) and ABC2 or " may need to be quoted depending on what delimiter you selected".

Question 2: Is there a semantic difference between the two representations above, when evaluated in Javascript?

No. In JavaScript they are identical.

I leave a quote from a presentation that Douglas Crockford (the creator of the JSON standard) gave to Yahoo.

He talks about how he discovered JSON, and amongst other things why he decided to use quoted keys:

.... That was when we discovered the unquoted name problem. It turns out ECMA Script 3 has a whack reserved word policy. Reserved words must be quoted in the key position, which is really a nuisance. When I got around to formulizing this into a standard, I didn't want to have to put all of the reserved words in the standard, because it would look really stupid.

At the time, I was trying to convince people: yeah, you can write applications in JavaScript, it's actually going to work and it's a good language. I didn't want to say, then, at the same time: and look at this really stupid thing they did! So I decided, instead, let's just quote the keys.
That way, we don't have to tell anybody about how whack it is.

That's why, to this day, keys are quoted in JSON.

You can find the complete video and transcript here.

If json describes objects, then in practise you get the following

var foo = {};


var bar = 1;


foo["bar"] = "hello";
foo[bar] = "goodbye";

so then,

foo.bar == "hello";
foo[1] == "goodbye" // in setting it used the value of var bar

so even if your examples do produce the same result, their equivalents in "raw code" wouldn't. Maybe that's why?? dunno, just an idea.

In javascript objects can be used like a hash/hashtable with key pairs.

However if your key has characters that javascript could not tokenize as a name, it would fail when trying it access like a property on an object rather than a key.

var test  = {};
test["key"] = 1;
test["#my-div"] = "<div> stuff </div>";


// test = { "key": 1, "#my-div": "<div> stuff </div>" };


console.log(test.key);           // should be 1
console.log(test["key"]);        // should be 1
console.log(test["#my-div"]);    // should be "<div> stuff </div>";
console.log(test.#my-div);       // would not work.

identifiers can sometimes have characters that can not be evaluated as a token/identifier in javascript, thus its best to put all identifiers in strings for consistency.

I think the right answer to Cheeso's question is that the implementation surpassed the documentation. It no longer requires a string as the key, but rather something else, which can either be a string (ie quoted) or (probably) anything that can be used as a variable name, which I will guess means start with a letter, _, or $, and include only letters, numbers, and the $ and _.

I wanted to simplify the rest for the next person who visits this question with the same idea I did. Here's the meat:

Variable names are not interpolated in JSON when used as an object key (Thanks Friedo!)

Breton, using "identifier" instead of "key", wrote that "if an identifier happens to be a reserved word, it is interpreted as that word rather than as an identifier." This may be true, but I tried it without any trouble:

var a = {do:1,long:2,super:3,abstract:4,var:5,break:6,boolean:7};
a.break

=> 6

About using quotes, Quentin wrote "...but you don't have to, unless [the key] contains certain characters (or combinations of characters that would make it a keyword)"

I found the former part (certain characters) is true, using the @ sign (in fact, I think $ and _ are the only characters that don't cause the error):

var a = {a@b:1};

=> Syntax error

var a = {"a@b":1};
a['a@b']

=> 1

but the parenthetical about keywords, as I showed above, isn't true.

What I wanted works because the text between the opening { and the colon, or between the comma and the colon for subsequent properties is used as an unquoted string to make an object key, or, as Friedo put it, a variable name there doesn't get interpolated:

var uid = getUID();
var token = getToken();            // Returns ABC123
var data = {uid:uid,token:token};
data.token

=> ABC123

It may reduce data size if quotes on name are only allowed when necessary