Binarymist

var method;                  // ok
var class;                   // illegal
object = {box: value};       // ok
object = {case: value};      // illegal
object = {'case': value};    // ok
object.box = value;          // ok
object.case = value;         // illegal
object['case'] = value;      // ok

var private = 'Oh yuk'; // if strict mode is on: Uncaught SyntaxError: Unexpected strict mode reserved word
var break = 'break me'; // Uncaught SyntaxError: Unexpected token break

var myFunc = function (private, break) {
   // if strict mode is on or off: Uncaught SyntaxError: Unexpected token break
   // strangly enough, private is always fine as a parameter.
}

var myObj = {
   private: 'dung', // no problem
   break: 'beetle' // no problem
}
console.log('myObj.private: ' + myObj.private) // myObj.private: dung
console.log(' myObj.break: ' + myObj.break); // myObj.break: beetle

2 Responses to “JavaScript Reserved Words”

1. David Kaye Says:
   July 2, 2012 at 07:22 | Reply

   Can you add clarifications to why new should be avoided?

   The new keyword is actually ver good – it has a performance benefit over call and apply and direct invocations – when used with constructors and prototypal lookup you get an enormous memory savings too –

   Thx

   • binarymist Says:
     July 3, 2012 at 00:33 | Reply

     Hi David.

     I’m curious as to what the performance benefit is over call and apply and direct invocations?
     Can you shed some light as to the enormous memory savings your talking about?

     Any time you call new, a new function is created in memory.
     Unless your adding new methods to the function, there is no point in creating another function that looks the same as the previous new’d function.
     If you are adding a new method, your better off to add it to the existing functions prototype.

     I didn’t say it should be avoided.
     I did say “use in moderation” though,

     and understand what happens with it’s usage in every different case.
     There are gotchas every where.
     Using new has many behaviours, depending on where and how you use it.
     Easily enough to devote a large blog post to.
     Which is why I’d recommend not using it.
     There are other ways to reap the same benefits without the nasty unexpected behaviour.

     Using new with Object() creates an instance based on the parameter you pass Object().
     Not always a bad thing (although some say it is), but can produce unexpected results if not careful.

     Forgetting to use new with a constructor function makes the function object’s this reference the global object.
     If using in a browser that doesn’t support ES5’s 'use strict' you won’t get a syntax or runtime error.
     If your constructor has this.myMember in it, your actually augmenting the global object with myMember.
     There are ways to make this less likely.
     1) Following the upper case first character rule.
     2) using the that convention. Add all members to that, then return that rather than the implicit return of this.
     function Waffle() {
var that = {};
that.tastes = "yummy";
return that;
}
     For simpler objects, you don’t even need a local variable such as that; you can simply return an object from a literal like so:
     function Waffle() {
return {
tastes: "yummy"
};
}

     You have the freedom to return any object in your constructors, as long
     as it’s an object. Attempting to return something that’s not an object (like a string or a
     boolean false, for example) will not cause an error but will simply be ignored, and the
     object referenced by this will be returned instead.

     Using any of the implementations above Waffle() always returns an object, regardless
     of how it’s called:
     var first = new Waffle(),
second = Waffle();
console.log(first.tastes); // "yummy"
console.log(second.tastes); // "yummy"
     The problem with this pattern is that the link to the prototype is lost, so any members
     you add to the Waffle() prototype will not be available to the objects.

     Inside the constructor function an object is created (which references the constructors prototype) and referenced by the this variable.
     this references the new constructor object, the constructors prototype object, and any properties of the new‘d constructor function.

     With ES5 if you ‘use strict’, if you forget to use the new prefix on a constructor, an exception will be thrown, rather than silently adding to the global object.

     Object.create I think is a better option than using new.
     It’s simpler and produces a more predictable result.
     You get the memory savings your talking about,
     and it can reduce object initialisation time.
     var child = Object.create(parent, {
age: { value: 2 } // ECMA5 descriptor
});
child.hasOwnProperty("age"); // true
     If you can’t wait for all browsers to support it, or your coding for legacy browsers as I am, you can hand role the function.
     Or use a library that has it.
     In YUI3 it’s the Y.Object() method.
     Or implement something similar your self:
     if (typeof Object.create !== 'function') {
Object.create = function (o) {
var F = function () {};
F.prototype = o;
return new F();
};
}
var childObject = Object.create(parentObject);

Leave a Reply Cancel reply

Enter your comment here...

Fill in your details below or click an icon to log in:

Email (required) (Address never made public)

Name (required)

Website

You are commenting using your WordPress.com account. ( Log Out /  Change )

You are commenting using your Facebook account. ( Log Out /  Change )

Cancel

Connecting to %s

Notify me of new comments via email.

Notify me of new posts via email.

Δ