These are numbers (or other values) simply used in line in your code. **Do not use these**, give them a variable name so they can be understood and changed easily.
*Right:*
```js
var minWidth = 300;
if (width <minWidth){
...
}
```
*Wrong:*
```js
if (width <300){
...
}
```
## Global definitions
Don't do this. Everything should be wrapped in a module that can be depended on by other modules. Even things as simple as a single value should be a module.
## Function definitions
Prefer the use of function declarations over function expressions. Function expressions are allowed, but should usually be avoided.
Also, keep function definitions above other code instead of relying on function hoising.
When using a chaining syntax (jquery or promises, for example), do not indent the subsequent chained operations, unless there is a logical grouping in them.
Also, if the chain is long, each method should be on a new line.
Feel free to give your closures a descriptive name. It shows that you care about them, and
will produce better stack traces, heap and cpu profiles.
*Right:*
```js
req.on('end', function onEnd() {
console.log('winning');
});
```
*Wrong:*
```js
req.on('end', function() {
console.log('losing');
});
```
## No nested closures
Use closures, but don't nest them. Otherwise your code will become a mess.
*Right:*
```js
setTimeout(function() {
client.connect(afterConnect);
}, 1000);
function afterConnect() {
console.log('winning');
}
```
*Wrong:*
```js
setTimeout(function() {
client.connect(function() {
console.log('losing');
});
}, 1000);
```
## Use slashes for comments
Use slashes for both single line and multi line comments. Try to write
comments that explain higher level mechanisms or clarify difficult
segments of your code. **Don't use comments to restate trivial things**.
***Exception:*** Comment blocks describing a function and it's arguments (docblock) should start with `/**`, contain a single `*` at the begining of each line, and end with `*/`.
While JavaScript it is not always considered an object-oriented language, it does have the building blocks for writing object oriented code. Of course, as with all things JavaScript, there are many ways this can be accomplished. Generally, we try to err on the side of readability.
### Capitalized function definition as Constructors
When Defining a Class/Constructor, use the function definition syntax.
*Right:*
```js
function ClassName() {
}
```
*Wrong:*
```js
var ClassName = function () {};
```
### Inhertiance should be done with a utility
While you can do it with pure JS, a utility will remove a lot of boilerplate, and be more readable and functional.
*Right:*
```js
// uses a lodash inherits mixin
// inheritance is defined first - it's easier to read and the function will be hoisted
_(Square).inherits(Shape);
function Square(width, height) {
Square.Super.call(this);
}
```
*Wrong:*
```js
function Square(width, height) {
this.width = width;
this.height = height;
}
Square.prototype = Object.create(Shape);
```
### Keep Constructors Small
It is often the case that there are properties that can't be defined on the prototype, or work that needs to be done to completely create an object (like call it's Super class). This is all that should be done within constructors.
Try to follow the [Write small functions](#write-small-functions) rule here too.
### Use the prototype
If a method/property *can* go on the prototype, it probably should.
```js
function Square() {
...
}
/**
* method does stuff
*@return {undefined}
*/
Square.prototype.method = function () {
...
}
```
### Handling scope and aliasing `this`
When creating a prototyped class, each method should almost always start with:
`var self = this;`
With the exception of very short methods (roughly 3 lines or less), `self` should always be used in place of `this`.
var ExternalClass = Private(require('path/to/some/class'));
...
});
```
### Promises
A more robust version of Angular's `$q` service is available as `Promise`. It can be used in the same way as `$q`, but it comes packaged with several utility methods that provide many of the same useful utilities as Bluebird.
This Javascript guide forked from the [node style guide](https://github.com/felixge/node-style-guide) created by [Felix Geisendörfer](http://felixge.de/) and is
licensed under the [CC BY-SA 3.0](http://creativecommons.org/licenses/by-sa/3.0/)