JavaScript Best Practices

Avoid worldwide variables,  keep away from new,  avoid  ==,  stay away from eval()

Avoid Global Variables

Minimize the utilization of worldwide variables.

This incorporates all information types, objects, and functions.

Global factors and capacities can be overwritten by other scripts.

Use nearby factors rather, and figure out how to utilize closures.

Always Declare Local Variables

All factors utilized in a capacity ought to be announced as local factors.

Local factors must be pronounced with the var keyword, else they will end up worldwide variables.

Declarations on Top

It is a decent coding practice to put all assertions at the highest point of each content or on the other hand function.

This will:

  • Give cleaner code
  • Provide a solitary spot to search for neighborhood variables
  • Make it less demanding to maintain a strategic distance from undesirable (inferred) worldwide variables
  • Reduce the likelihood of undesirable re-declarations
/Declare at the beginning
var firstName, lastName, value, rebate, fullPrice;

//Use later
firstName = "John";
lastName = "Doe";

price = 19.90;
rebate = 0.10;

fullPrice = cost * 100/discount;

This additionally goes for circle variables:

/Declare at the beginning
var i;

//Use later
for (I = 0; I < 5; i++) {

Initialize Variables

It is a decent coding practice to introduce factors when you proclaim them.

This will:

  • Give cleaner code
  • Provide a solitary spot to introduce variables
  • Avoid unclear values
/Declare and start at the beginning
var firstName = "",
    lastName = "",
    cost = 0,
    rebate = 0,
    fullPrice = 0,
    myArray = [],
    myObject = {};

Never Declare Number, String, or Boolean Objects

Always treat numbers, strings, or booleans as crude qualities. Not as objects.

Declaring these sorts as articles, backs off execution speed, furthermore, produces dreadful side effects:


var x = "John";             
var y = new String("John");
(x === y)/is false on the grounds that x is a string and y is an article.
Try it Yourself »

Or even worse:


var x = new String("John");             
var y = new String("John");
(x == y)/is false in light of the fact that you can't analyze objects.
Try it Yourself »

Don't Use new Object()

  • Use {} rather than new Object()
  • Use "" rather than new String()
  • Use 0 rather than new Number()
  • Use false rather than new Boolean()
  • Use [] rather than new Array()
  • Use/()/rather than new RegExp()
  • Use work (){} rather than new Function()


var x1 = {};          /new object
var x2 = "";          /new crude string
var x3 = 0;           /new crude number
var x4 = false;       /new crude boolean
var x5 = [];          /new cluster object
var x6 =/()/;        /new regexp object
var x7 = function(){}; //new capacity object
Try it Yourself »

Beware of Automatic Type Conversions

Beware that numbers can incidentally be changed over to strings or NaN (Not a Number).

JavaScript is inexactly composed. A variable can contain diverse information types, and a variable can change its information type:


var x = "Hello";     //typeof x is a string
x = 5;               //changes typeof x to a number
Try it yourself »

When doing scientific tasks, JavaScript can change over numbers to strings:


var x = 5 + 7;      /x.valueOf() is 12,  typeof x is a number
var x = 5 + "7";    /x.valueOf() is 57,  typeof x is a string
var x = "5" + 7;    /x.valueOf() is 57,  typeof x is a string
var x = 5 - 7;      /x.valueOf() is - 2,  typeof x is a number
var x = 5 - "7";    /x.valueOf() is - 2,  typeof x is a number
var x = "5" - 7;    /x.valueOf() is - 2,  typeof x is a number
var x = 5 - "x";    /x.valueOf() is NaN, typeof x is a number
Try it Yourself »

Subtracting a string from a string, does not produce a blunder however returns NaN (Not a Number):


"Hello" - "Dolly"   /returns NaN
Try it Yourself »

Use === Comparison

The == examination administrator dependably changes over (to coordinating sorts) previously comparison.

The === administrator powers examination of qualities and type:


0 == "";       /true
1 == "1";      /true
1 == true;     /true

0 === "";      /false
1 === "1";     /false
1 === true;     /false
Try it Yourself »

Use Parameter Defaults

If a capacity is called with a missing contention, the estimation of the missing contention is set to undefined.

Undefined qualities can break your code. It is a decent propensity to appoint default qualities to arguments.


work myFunction(x, y) {
    if (y === indistinct) {
        y = 0;
Try it Yourself »

Read increasingly about capacity parameters and contentions at Function Parameters

End Your Switches with Defaults

Always end your switch explanations with a default. Regardless of whether you think there is no requirement for it.


switch (new Date().getDay()) {
    case 0:
        day = "Sunday";
    case 1:
        day = "Monday";
    case 2:
        day = "Tuesday";
    case 3:
        day = "Wednesday";
    case 4:
        day = "Thursday";
    case 5:
        day = "Friday";
    case 6:
        day = "Saturday";
        day = "Unknown";
Try it Yourself »