JavaScript Best Practices
Tags: javascript
Published: 2020-01-28 09:43:19

---
title: JavaScript Best Practices
published: true
tags: javascript
canonical_url: 
---

JavaScript is not only amazing language but also very tricky language. To make correct use of it, you need to follow some best practices to avoid any problems that might come about otherwise. I share some of the best practices you really should be following when writing JavaScript code. Of course this is not an exhaustive list but at the most fundamental level, every programmer should know and adhere to it.

## 1 -NEVER FORGET `VAR` KEYWORD

Most of the developers know about this but yet I wanted to mention this because it may not be clear to some or newbies or people having other programming language background that come to JavaScript.

Consider the following piece of code:

```
function myFunc(){
    var firstName = 'sarfraz';
    lastName = 'ahmed';
}
```

It should be noted that in JS, variables have function-level scope which means a variable declared inside a function can not be accessed outside of it. So letâs test above two variables:

```
myFunc();
console.log(lastName); // ahmed
console.log(firstName); // undefined
```

As you will notice, we are still able to access `lastName` variable. The reason is that it does not have function-level scope because we forgot to put var keyword before it unlike `firstName` variable. Hence, `lastName` variable went into **global** scope and became part of `window` (while inside browser) object eg `window.lastName` will output the last name too.

It is therefore always required to put `var` keyword before variables so that they do not become part of global scope. It has following benefits:

- You save the memory and improve performance
- You donât pollute the global scope
- You mistakenly donât overwrite a global variable that might have the same variable name

This is a very important concept and JS developers have always been finding solutions to avoid this problem. One of the most popular solution is [Singleton](http://chrisiona.com/learning-modern-javascript/the-singleton-pattern/) or [Module Pattern](http://www.adequatelygood.com/2010/3/JavaScript-Module-Pattern-In-Depth) you should check out. By the way, if you want to see other patterns also, take a look at:

[Essential JavaScript Design Patterns For Beginners](http://addyosmani.com/resources/essentialjsdesignpatterns/book/)

## 2 â DECLARE VARIABLES ON TOP

Another thing that should be followed is that variables should be declared on top of each function because of what is known as **JavaScript Hoisting**. Here is an example:

```
var name = 'sarfraz';

(function(){
console.log(name); // undefined
     var name = 'nawaz';
     console.log(name); // nawaz
})();
```

Notice that even though `name` variable is outside the scope of function but on the very first line it gives back `undefined` rather than actual name. The reason for this is that interpreter hoists or moves variables on top of the function, here is how interpreter sees or re-arranges it:

```
var name = 'sarfraz';

(function(){
     var name;
     console.log(name); // undefined
     name = 'nawaz';
     console.log(name); // nawaz
})();
```

As can be seen, `name` variable has been hoisted to top and declared there and also `var` keyword has been stripped from it where we assigned the value of `nawaz`.

The same is issue is not only with variables but also **function declarations** but NOT with **function expressions**. You can learn more about the difference between function declaration and function expression here:

[Named Functions Demystified](http://kangax.github.com/nfe/)

The solution to this problem is to always declare **variables and function declarations** on top of container function:

```
function myFunc(){
     var foo;
     var bar;
     var baz;

     // do something foo, bar, baz
}
```

The preferred and recommended syntax though that you must follow is to declare all variables in one go by separating them with a comma:

```
function myFunc(){
     var foo, bar, baz;

     // do something foo, bar, baz
}
```

## 3 â INITIALIZING MULTIPLE VARIABLES

Declaring variables on top is good practice but not _multiple initialization_. Consider:

```
function myFunc(){
    var lang = encoding = 'en';
}
```

This is a very common mistake even amongst experienced JS developers where they think they have quickly assigned two variables same scope and same value. Though value for both `lang` and `encoding` variable is some but not the scope. Try it out:

```
myFunc();
console.log(encoding); // en
console.log(lang); // undefined
```

Here again, variable `encoding` has gone into global scope. Since `var` keyword is only appears before `lang` variable, that is the one which gets correct functional scope. In short, you should avoid that shorthand initialization unfortunately.

## 4 â STARTING CURLY BRACE ON THE SAME LINE

Consider the following code block where starting curly brace `{` is on a new line, this works fine in most situations:

```
function myFunc()
{
    // some code
}
```

However, same convention will not yield expected results if you happen to write:

```
function myFunc()
{
     return
     {
         name: 'sarfraz'
     };
}

var f = myFunc();
console.log(f);
```

The result will be `undefined` because behind the scenes, interpreter puts a semicolon `;` after the `return` keyword making it:

```
function myFunc()
{
     return; // <----------------
     {
         name: 'sarfraz'
     };
}
```

To remedy such hard-to-debug issues, it is good practice to always put starting curly brace on the **same line** , this would work fine though:

```
function myFunc() {
     return {
         name: 'sarfraz'
     };
}

var f = myFunc();
console.log(f.name); // sarfraz
```

And thatâs a reason why [Douglas Crockford](http://www.crockford.com/) in his book â[JavaScript: The Good Parts](http://www.amazon.com/JavaScript-Good-Parts-Douglas-Crockford/dp/0596517742)â, advocates this syntax for JS:

```
function () {
     // some code
}

if (expression) {
     // do something
}
```

Go ahead and check out [JavaScript Coding Style](http://javascript.crockford.com/code.html) to learn more as well as naming conventions.

Notice that it is not the `return` keyword affected by automatic semi-colon insertion but all these too:

- **var** statement
- **empty** statement
- **expression** statement
- **do-while** statement
- **continue** statement
- **break** statement
- **throw** statement

Experienced JavaScript developers know pretty well about JavaScriptâs _automatic semi-colon insertion problem_ and avoid it. The benefit of above coding style however is that you avoid this problem without knowing that this problem exists just by following that coding style.

## 5 â USE ARRAY LITERAL INSTEAD OF NEW ARRAY()

There are two ways you can create arrays in JS:

```
var arr1 = new Array(); // array constructor
var arr2 = []; // array literal
```

Though both serve the purpose of creating arrays but there is important difference between the two.

In JS, even an array is an object. With first constructor method above, you are telling interpreter to call constructor of the `Array` and generate an object. The interpreter looks up into the execution context to find the constructor and once found, it calls it and creates the `Array` object. It seems that it has performance hit too as compared to latter array literal method. With the array literal method, interpreter just creates the array on run-time with no extra processing done.

Other than that, Array constructor is mis-guiding the way it handles its parameters. Consider:

```
console.log(new Array(5)); // [,,,,]
console.log(new Array('5')); // ["5"]
```

When one argument is passed to Array and that happens to be a number, a new array is returned with its length property equal to that number passed. The important thing to note here is that Array will be initialized from what number you specified to it, for example:

```
// Array constructor
var arr = new Array(2);
console.log(arr.length); // 2
console.log(arr[0]); // undefined

// Array literal
var arr = [2];
console.log(arr.length); // 1
console.log(arr[0]); // 2
```

So the conclusion is to always use array literal notation rather than Array constructor.

## 6 â USE PROTOTYPE TO SHARE ACROSS

The concept of prototypes or prototypal inheritance is rather confusing. I have seen people especially inexperienced JS developers adding class members to parent function which needs to be shared across child classes. Consider the following code:

```
function Person(name){
    this.name = name;
}
```

Now letâs assume we want to have child classes the ability to display the names some how, one of doing it is putting method directly inside `Person` class:

```
function Person(name){
     this.name = name;

     this.display = function(){
         alert(this.name);
     }
}
```

Other way is to use `prototype`:

```
function Person(name){
     this.name = name;
}

Person.prototype.display = function(){
     alert(this.name);
}
```

With both ways, all child classes will be able to use the display method but there is important difference between the two. When you attach any methods or properties via `this` (first way above) to a class then all instances of inheriting child classes will also have these properties or methods within them or their signature. On the other hand, when you use `prototype` to add members (properties and methods) to parent class, children classes will still inherit all members but it wonât be present inside their own functionality or signature, rather they will be borrowing that functionality from their parent class thereby saving memory. For this reason, later approach seems good to follow in most situations.

## 7 â PUT COMMA BEFORE PROPERTIES

When working with objects or arrays, it is always a good idea to put a comma before the variable or object property eg:

```
// jQuery - create a new div with some css
$('<div>').attr({
   "id" : "myId"
 , "class" : "myClass"
 , "class" : "myClass"
 , "color" : "green"
 , "fontWeight" : "bold"
});
```

In this way, we never add an extra comma or forget one from the last property. The reason why this is good practice is that, in IE, with extra comma at the last property, we do not get expected results sometimes ( **ExtJS** developers must have learned this). I do the same with multiple variable declarations or arguments of function. It also makes the code look pretty too as far as I see it.

## 8 â DONâT MIX JS AND HTML

One of the most important best practices is to always _separate JS code from HTML_ and go [unobtrusive](http://en.wikipedia.org/wiki/Unobtrusive_JavaScript). One would often see code like this:

```
<a href="#" onclick="doSomething()">Some Action</a>
<input type="button" onclick="doSomething()" value="Do Something" />
<form onsubmit="doSomething();">...
```

Thatâs a very bad practice in that it is hard to manage and maintain. HTML and JS should not be mixed ever. You could do the same thing like this:

```
<a href="#" id="link">Some Action</a>
<input type="button" id="button" value="Do Something" />
<form id="frm">...

<script type="text/javascript">
var link = document.getElementById('link'),
 btn = document.getElementById('button'),
 frm = document.getElementById('link');

link.onclick = function(){
 // do something
};

btn.onclick = function(){
 // do something
};

frm.onsubmit = function(){
 // validate form
};     
</script>
```

This way it becomes easy to manage, maintain or enhance both HTML and JavaScript.

## 9 â PUT SCRIPTS AT BOTTOM

Normally scripts are put in `<head></head>` tags but this should be avoided. The reason for this is that browser loads your scripts sequentially and by the time they are loading, nothing else is done and website load times slow down (or at least thatâs how visitors will perceive it) and you see actual output only after those scripts have been loaded by the browser.

The best practice is that scripts should be put on bottom of page just before closing body tag eg `</body>`. This way browser will instantly display page and page load time will be better for users who view that page.

By the way, always put CSS on top in `<head></head>` tags because thatâs something browser reads first and renders pageâs layout accordingly.

Read more about this at famous [Yahooâs performance article](http://developer.yahoo.com/performance/rules.html).

I would also suggest you to use Yahooâs [YSlow](http://developer.yahoo.com/yslow/) or Googleâs [PageSpeed](http://code.google.com/speed/page-speed/) add-on (add-ons of [Firebug](http://getfirebug.com/)) which suggest you a lot of things on how to improve the performance of the page.

## 10 â NEVER FORGET SEMI-COLON

Always end statements and function expressions with a semi-colon:

```
var name = 'some name'; // <-------------

var myFunc = function(){
// some doe

}; // <------------
```

This is useful when you want to compress the code (for faster load times). If at any place, semi-colon isnât present, you wonât be able to compress the code or wouldnât get expected results most likely code-wise. You should always, always use semi-colons.

## BONUS

The good news is that you can solve most of above problems by using [JSHint](http://www.jshint.com/) or [JSLint](http://jslint.com/) code quality tool. It will tell you about best-practices and any errors that might exist in your code. Having said that, it is good to improve your JS skills and avoid the need to go to such tools.

 ![](http://feeds.feedburner.com/~r/codeinphpfeed/~4/Ys_foOiEpMU)