On Mar 20, 2011, at 12:49 PM, Andrew Dupont wrote:
> OK, you lost me.
>
> On Mar 20, 2011, at 2:36 PM, Allen Wirfs-Brock wrote:
>
>> On Mar 20, 2011, at 10:55 AM, Andrew Dupont wrote:
>>
>>> Right; I think Dean and I are saying that this would be the first time
>>> obj.foo meant something different from obj['foo']. And to ascertain that
>>> those two meant different things, I'd have to go searching through the code
>>> for a `private foo` declaration.
>>
>> With the private name proposal obj.foo and obj.[#.foo] will always mean the
>> same thing regardless of whether foo is scoped as a private name or as a
>> regular property name.
>
> I'm not comparing `obj.foo` and `obj[#.foo]`; I get that those two are
> equivalent for private names. (I don't know what you mean when you say those
> are the same for public names, though, because I don't know what `obj[#.foo]`
> means in a public context.)
From the Private Names Strawman:
The syntactic form is #. IdentifierName. This may be used as a
PrimaryExpression and yields the property name value of the IdentifierName.
This may be either a private name value or a string value, depending upon
whether the expression is within the scope of a private declaration for that
IdentifierName;
>
>
>> BTW, if you know that a property name is foo, why would you ever code
>> obj["foo"] instead of obj.foo?
>
> The proposal strongly implies that the `private` declaration affects only "a
> property name on the right of . or the left of : in an object initialiser."
> Does it also affect bracket notation? In other words:
>
> private foo;
> obj.foo = 42;
> obj['foo'] === obj.foo; // true or false?
>
> If the answer is `false`, that's your answer for why I'd ever code
> `obj['foo']` instead of `obj.foo`. If the answer is `true`, then that answers
> one of the questions I was asking earlier; but it also means that there's no
> way to get around the fact that the `private` declaration is "shadowing" any
> possible use of a public property name called `foo` in the same lexical scope.
as Sam answered, the answer is false.
// test if a property name is a private name in the current scope:
if (#'foo==='foo') {
//foo is bound when used as a property name to its default string value,
not a private name value
} else {
//foo has a private name binding
}
Yes, I appreciate that if private names existed you might use obj['foo'] to
guarantee you were accessing a string-named property. However, my original
comment was in response to your statement "It would mean a new and
_surprising_ distinction between dot notation and bracket notation." I was
trying to argue (apparently not very effectively) that there was already a
significant distinction between dot notation and bracket notation and that
private name is just building upon that distinction. Without private names
there is no particular reason to say obj['foo'] rather than obj.foo but there
is a very important distinction between obj[foo] and obj.foo. The private
names proposal preserves that distinciton.
Allen
>
> Cheers,
> Andrew
_______________________________________________
es-discuss mailing list
[email protected]
https://mail.mozilla.org/listinfo/es-discuss
