Why is dot notation more intuative? Because some other languages use it for namespacing? Since JavaScript identifiers don’t usually use underscore, it is available for some other meaning like namespacing. Using a dot costs as property lookup in JavaScript.

> 2. Dot-notation allows you to make convenience aliases to any node in the namespace hierarchy. For example, if I’m going to be referring to various members of the Logger class, I can do “var logr = acme.widgets.Logger” inside my function, and then refer to “logr.foo”. It’s easier to type and more compact.

I can do “var foo = acme_widgets_Logger_foo;” and then just refer to “foo” which is less characters and executes faster. I’m not worried about “this” as I don’t use it in API functions.

> 3. Dot-notation allows for a variety of shortcuts when constructing nested APIs. For example, you can use the literal object syntax to build a nested API like this:
>
> var acme = {
> widget: {
> Scroller: function () {
> }
> }
> }

I don’t see this as a significant advantage. It isn’t so hard to write

acme_Scroller = function (){}

I don’t think there is any need for a middle “widget” namespace.

> 4. Dot-notation is easier to type.

I don’t end up typing underscore as often as you might think.

Additionally, the ‘(function(global){})(this);’ syntax is not necessarily bad as it provides access to the global scope in exotic JS engines like screenreaders or standalone spidermonkey/ Rhino, but it forces a function call during script initialization, which will slow down the startup of your app. Using this method to declare your own namespace globally, shows another advantage of using a namespace:

(function(global){
// declaring your namespace here saves you from using the
// (function(global){})(this); struct anywhere else.
global.jpf = {
// stuff...
};
})(this);


Another thing I noticed when looking at Peter’s code, is his ‘LIB_updateElement()’ statement, which contains a string, concatenated with the ‘+’ operand. It works, but is unnecessarily slow. I suggest using the following syntax whenever and wherever possible:

// Delimiting strings with a backslash '\' saves you a string concat and
// still allows you to format your code within 80 characters with
// indenting:
LIB_upateElement(parser,
'\
clear\
\
');

With all the research flying around, I’d recommend this syntax to all.

I don’t have a test page with raw metrics online somewhere, but I can put one up if someone feels I should (again :P) prove my aforementioned statements.

1. “dot” notation is (for me) much more intuitive when dealing with nested namespaces. For example, “new acme.widgets.Logger()” just reads better than “new acme_widgets_Scroller()”. The latter creates a cognitive clash between two nameing conventions I’ve long since grown accustomed to. “_” separated identifiers tend to be all lower (or upper) case, but in JavaScript the convention is to capitalize Class names but not generic objects. Thus, it just looks wierd.

2. Dot-notation allows you to make convenience aliases to any node in the namespace hierarchy. For example, if I’m going to be referring to various members of the Logger class, I can do “var logr = acme.widgets.Logger” inside my function, and then refer to “logr.foo”. It’s easier to type and more compact.

3. Dot-notation allows for a variety of shortcuts when constructing nested APIs. For example, you can use the literal object syntax to build a nested API like this:

var acme = {
widget: {
Scroller: function () {
}
}
}


4. Dot-notation is easier to type. You young pups may not care, but as a professional programmer of 20+ years, my hands and wrists will feel the difference between a “_” convention where I have to use SHIFT all the time, and a “.” convention where I don’t, after a long day of coding.

“Now get off my lawn!” ;-)

Is there any benefit of *not* using “window.foo = …” ?

Is “global” really global? What I would expect from a variable called global (in a JavaScript program) is an object that hold global variables for the use of the entire program. (I’m in the habit of “var that=this;” instead, mostly because I see other people use it so much.)

The misspelling of sanitize drives me crazy. If I recall correctly, on the Atari ST, all the color functions had the word “palette” misspelled as “pallete.” Every time I got to one of those functions I had to slow down, grit my teeth, and think.