What is the best-practice casing style for javascript? Why?

Question

One aspect of javascript that it's hard to find information on is casing practices. By casing practices, I mean what casing style (ie. camel-case, pascal-case, etc) should be used for what elements (Constructors, private functions, public functions).

The only rule I've heard was from a Douglas Crockford lecture on YUI theater, stating that constructors should be the only functions that start with an uppercase letter.

Beyond that there doesn't seem to be many casing standards that people follow in javascript.

Does anyone know any casing best practices for javascript, and why it's reasonable to use them?

Also do you follow a casing style with your .js files?

Sickle

Answer 1

I prefer PascalCase for constructors and camelCase for everything else. That's the style that JS standard library uses and well... every JS framework I've seen so far :)

And I use all_lowercase naming convention for all files served from web. There are some case-insensitive file systems out there.

Ophthalmia

Can you only imagine if there was a mainstream case-insensitive modern OS xD How stupid would that be! – Middlings

Answer 2

The core language uses InitialCaps for constructors (e.g. Object, Date, Number, RegExp) and camelCase for methods and properties (e.g. something.toString(), quantity.valueOf(), regexp.ignoreCase). This convention is also followed in the DOM specifications and implementations (e.g. HTMLElement.setAttribute()). So it makes the most sense to adopt the same convention, or you finish up with a horrendous mishmash of styles like:

var number_of_fish_requested = document.getElementById("fish").value;
var fish_count = parseInt(number_of_fish_requested, 10);

which just becomes utterly confusing, not only to type but, much more importantly, to read.

(You spend more time reading code, trying to debug or modify it, than you ever do writing it in the first place.)

Embus

Answer 3

What I have seen so far is a very large diversity of casing standards.

As far as I'm concerned, I use C# styling for writing my JavaScript code. I use classes a lot (well functions as classes, and usually don't have independent functions.) So, I use PascalCase for class names, public methods, properties and all global variables and camelCase for arguments, local variables and private functions. This somehow reflects my common environment, helping to distinguish the variable scopes. I also tend to keep my class functions in a separate file with the same name as my ClassName (ClassName.js, ClassName.min.js).

This was about my approach.

I also noticed that Java programmers, follow the Java rules (and the writing style resembles the Java language.) Ruby on Rails programmers follow their own naming standards such as underscore_separated_var_name.

Further, as you mentioned, there is a tendency to use pascalCase a lot in naming in very popular frameworks whose authors come from different communities like Linux/Open source community and Microsoft developers (jQuery, knockout.js, JSJaC, etc.)

I should note that none of these methods are wrong or right, when it comes to JS. The primary purpose of your naming conventions and file structuring is the readability. If you are consistent then you in future and your fellow developers will quickly understand and get on with your code.

Villon

Answer 4

I prefer camelCase for everything except for constructors. The reason (and I believe this is why Mr. Crockford suggested this as well) is because in other languages, such as Java, the convention is capitalize your classes, which is what constructors are used for.

That is my $0.02.

Nola

Answer 5

All lower case with underscore separators is the easiest to read; it follows natural language. "Best" will get you in to a holy war; the reality is case doesn't matter as much as other design issues but it's an easy topic to polarize.

ALongButNotReallyReadableIdentifier
an_even_longer_but_completely_readable_identifier

Salt

But 'easiest' doesn't particularly avoid any holy wars. I say Pascal and camel case are easier to read than underscores, which you say is the 'easiest'. Now who is right? – Fogbound

You're right there's no way for me to prove that as "wrong". Most people who study how brains divide up English prose observe that the brain will divide up a sentence in to words separated by space. The brain will then do a pattern recognition on the first and last letters of each word, the approximate length of the word, and apply context to derive semantics. It's true one could teach themselves to read a different type script but there would have to be good reason to divert from standard English. – Salt

Your example is interesting. AnEvenLongerButCompletelyReadableIdentifier works OK, because you don't have 2 capitals butted up against each other at the beginning. – Sisco

Answer 6

The accepted answer is true but there are some exceptions. In window.JSON and window.XMLHttpRequest the term is capitalized.

Also most people use PascalCase for enum type objects in Javascript and capitalized values within. Sometimes namespaces are done in PascalCase also.

example: MyCompany.Web.UI.MyComponent.ThemeOption = { BLACK: 0, SILVER: 1, BLUE: 2}

Cocteau