

Javascript the right way - cfontes
http://jstherightway.com/

======
Ramone
Looks more like JS the java way. Singletons make no sense in a language that
has global variables and never lets you stop an object from being duplicated.
The command pattern makes no sense in a language with first-class functions.
I'd steer clear of this resource if you want to write javascript the right
way.

~~~
se85
I somewhat agree with your points.

You can't just explain every single design pattern available in any given
language and then say, you now know how to write that language "The right
way!".

Thats the feeling I got from this, it just goes into way too much detail about
way too many things, and forgets to start with the basics, which is all you
need to know to write JavaScript the right way.

How can you write any language the right way without knowing the basics?

This book could be an absolute disaster in the hands of people who don't know
any better.

+1 for steering clear of this resource.

~~~
TazeTSchnitzel
Yeah. I was expecting things like "use semicolons", "global variables are
bad", "=== is often what you want, not ==". These are the things that many
devs will need to learn. A bunch of design patterns was not what I expected.

~~~
georgemcbay
While I agree with the fact that the title is misleading, I would have been
even more disappointed if it was just a restating of "JavaScript: The Good
Parts".

------
tnorthcutt
I really like the nav highlighting used on this (and
<http://phptherightway.com>). Specifically, I like that it highlights the nav
element(s) for whichever sections are in view, rather than highlighting only
one nav element at a time. Very elegant.

~~~
jlogsdon
Check out Bootstrap's Scrollspy[1]. Its one implementation (of probably many)
that I've seen of the nav highlighting that you mentioned.

[1]
[http://twitter.github.com/bootstrap/javascript.html#scrollsp...](http://twitter.github.com/bootstrap/javascript.html#scrollspy)

------
jarek-foksa
The way how Addy Osmani implements singleton pattern is rather disputable. I
would implement singleton as a regular object that returns itself immediately
if initialized for the second time.

His prototype pattern also doesn't look like the right way of doing things. Is
there actually anyone that uses plain object descriptors? I would just create
helper method that wraps Object.create() and takes prototype object as first
argument and instance object as second argument. There is no need to use
constructors in this pattern (either directly or inside helpers) unless you
are targetting legacy browsers.

I also dislike the fact that public/local scope is emulated by misusing the
return statement - this is ugly, confusing and it doesn't play nicely with
other patterns such as prototype. If you need some notion of public/private
scope then just use underscore notation.

~~~
Androsynth
The singleton pattern he presents is pretty common and pretty powerful. It is
a self-invoking module. It allows you to use the module pattern (very solid js
pattern) and probably has less code than your method.

Also, javascript has closures, use them. this._private is a hacky java-esque
way of doing things. return {public_methods...} is a solid way of working
towards the strengths of the language and doing proper js encapsulation.

As for the prototype pattern, there are a million ways you can do that. Best
to learn the fundamentals so you can use whatever works best based on the
situation.

edit: I should add that one of the reasons I like JS patterns is that there
are multiple correct ways to implement them based on the situation. There are
many wrong ways too, of course :) but it is a very flexible language.

~~~
jarek-foksa
Here is what I prefer to call a singleton in JS, I don't think it could be any
simpler than that:

    
    
      mySingleton = {
        initialized: false,
    
        init: function() {
          if (this.initialized == false) {
            this.initialized = true;
            // Initialize the singleton here
          }
          return this
        },
      }
    
      singleton1 = mySingleton.init()
      singleton2 = mySingleton.init()
    

Both underscore notation and returning "public" methods feel awkward in
JavaScript, though the second appraoch introduces major trade-offs which I
belive are not worth it. E.g. how do you create inheritance chains when using
this pattern? Are you just copying public methods returned from one object
into another? Or how do you inspect private properties in Dev Tools? Are you
setting breakpoints for that purpose?

------
tnorthcutt
Why does this site say (at the bottom, under the license) _Based on a work
at<http://jstherightway.com>. _?

I noticed that PHP The Right Way (the inspiration for this site) says
something similar: _Based on a work at www.phptherightway.com._

~~~
projectedoptics
Since it's on Github - I guess it's for anyone who might fork and modify it,
so that there's a link back to the original:

<https://github.com/braziljs/js-the-right-way>

~~~
tnorthcutt
Ah, that makes sense (as does the answer given by sjs382). Thanks.

------
TazeTSchnitzel
No mention of Crockford? :(

~~~
debacle
With all due respect, Crockford jumped the shark some time ago.

~~~
TazeTSchnitzel
In what sense?

~~~
debacle
Crockford is as important to modern JS as Lerdorf is to modern PHP. He has a
very minimal role in the community, and most of that involves resting on his
laurels and being divisive.

~~~
TazeTSchnitzel
Really? I'd see him as quite important to modern JS. Heck, he discovered JSON,
that's certainly important, and he helps shape the ECMAScript standards. To
ignore him would be foolish.

------
ruxkor
A very nice initial listing for applications, I'd love to see it completed!

One framework I think is missing in the category "server-side" is derby.js (
<http://derbyjs.com> ), have you thought about adding it to the list?

~~~
lukifer
I loves me some Derby (and Racer), but it's not ready for production use until
it supports server-side authentication logic. (Supposedly it's on the way.)

~~~
coderzach
It does support server side authentication logic, it's just not very well
documented yet ;-)

~~~
lukifer
If it isn't documented, it doesn't exist. :) Glad to hear it, though!

------
eterps
If you use JavaScript on the client side, you do it to drive the user
interface which consists solely of DOM element objects. So why not make those
DOM elements object oriented instead:
<https://github.com/hafriedlander/jquery.entwine>

~~~
jarek-foksa
<http://i.imgur.com/Ml2Jb.jpg>

Sorry, I couldn't resist...

------
gnuwilliam
Hi guys! This a WIP, and we'd like to ask for your help to get this guide more
complete! It's a live document.

Please, feel free to fork the project and send a pull request, we really want
to make this guide a reference for JavaScript developers.

