On 2010-07-23 08:18 PM, David Mark wrote:
On 2010-07-23 01:12 PM, Alan Gutierrez wrote:
[snip informative explanation]
Thank you. Learn something new every day.
function Person(){}
Person.prototype = {};
var a = new Person;
Use the call operator. Thanks.
There isn't a call operator in ECMAScript.
Oh brother. And, in your world, what do you call it?
If you weren't a perpetual jerk or if you had at least asked a smart
question non-insulting manner, I'd probably try and guess as to what I
think you might have meant.
If you weren't such a perpetual loser, perhaps you wouldn't have to be
corrected so often.
But instead, you posted -- and it was pointed out -- your own made-up
terminology to make a rather pointless comment.
I did no such thing. Your nonsensical reply demonstrates nothing but
your own ignorance.
Do you have a special version of ECMA-262 that defines a call operator,
or did you just not RTFM?
You made a comment on code I wrote just few posts back "Please use the
call operator thanks".
So you missed the problem and made up some nonsense. Ironically, the
document that explains the actual problem sheds light on your irrelevant
nonsense.
Two, actually. What is more
ironic is that in the code guidelines document[2] goes to great length
to explain the problem and in so doing, explains the lexical grammar
production for what might likely be your "call operator" thing.
You are such a numb-skull.
No, that's you.
It was a rhetorical question.
That's not how I saw it.
And so, instead of calling the call operator what it is, you refer to
it as "Arguments". I'm sure that won't cause any confusion.
I refer to `Arguments` as `Arguments`; not as "call operator" -- that's
your made-up terminology. The production for `Arguments` is clearly
defined in ECMA-262 under 11.2 Left-Hand-Side Expressions.
Anyone can see quickly that production is defined under "Left-Hand-Side
Expressions" in ECMA-262. For convenience:
<
http://bclary.com/2004/11/07/#a-11.2>
| Arguments:
| ()
| ( ArgumentList )
And so continuing to call `Arguments` the "call operator" shouldn't be
fooling anybody at this point. It is somewhat revealing to the facade
that there actually is such a thing (there isn't, go RTFM) and that you
know what you're talking about (pretty obvious that you don't).
If there were such a thing, then the pertinent part of the spec could
have been cited and the discussion of the alleged "call operator" would
have been quickly resolved. However anyone can RTFM see that you're full
of shit.
The reason it is misleading to call `Arguments` a "call operator" is
that the production `Arguments` is used in NewExpression and
CallExpression, respectively, as:
new MemberExpression Arguments
and
MemberExpression Arguments
- and so it wouldn't make sense to refer to something used for `new` as
a "call" operator; the example code I posted was using `new`, which
calls `[[Construct]]`, not [[Call]].
Being faced with a fact with overwhelming evidence is too uncomfortable
for you to accept and so you reject reality and use name calling instead.
Now here's a rhetorical question: What does it say about you when you
hurl insults while continuing to use your own made-up terminology, even
after it being pointed out to you?
You could have stopped with "unreliable source of information regarding
ECMAScript," but you seem intent on destroying your reputation with
obvious falsehoods.
