Common thing that all javascript programmers search on the web more than once in your career!!!am I right?
It's pretty cool to understand the javascript variable declaration before the era of big gun ES6! The one and only one king - var
keyword. On introducing ES6 we have another couple of keywords to implement the variable declaration- let
and const
.
The best way to understand these keywords by comparing them based on 3 features.
1. Scope of variable
2. Redeclaration
3. Hoisting
Scope of variable
When we declare a variable in JS, the lifetime of the variable in our code is defined as the scope of the variable.
using var keyword
The variable created with var
keyword has a scope of current execution context. That means, if the variable is declared outside of all the functions and block of codes, it's scope is global otherwise local to the function or block of codes.
The one important thing is that if the scope of the variable is global it can be accessed with the window
object(only in the case of var
keyword!).
// Global Scope
var varVariable = "John Doe";
console.log(varVariable); // Output: "John Doe"
console.log(window.varVariable); // Output: "John Doe"
// Local Scope to the function
function() {
var varVariable = "John Doe";
console.log(varVariable); // Output: "John Doe"
}
console.log(varVariable); // Output: undefined
console.log(window.varVariable); // Output: undefined
using let keyword
The let
keyword variables have only blocked scope in code execution. That means if a variable declared with let
outside of all the functions and block of codes, it's scope is limited to the end of the execution of the code. Otherwise scope is limited to the block or function in which the variable is declared.
Are you confused about the above paragraph? both the var and let keywords are similar when declaring outside of all functions? Maybe you are confused!!
If your answer is a YES, then go to the Hoisting section of this article and read about the let keyword. Then you get a better understanding of the difference. The let
and var
keyword are almost similar...
// Variable scope is available to the end of the execution of the code.
let letVariable = "John Doe";
console.log(letVariable); // Output: "John Doe"
console.log(window.letVariable); // Output: undefined
// Block Scope to the function
function() {
let letVariable = "John Doe";
console.log(letVariable); // Output: "John Doe"
}
console.log(letVariable); // Output: undefined
console.log(window.letVariable); // Output: undefined
using const keyword
const
is a new one for declaring immutable variables in Javascript. that means variable that doesn't change their value when the code execution progress through line by line.
Similar to let
keyword, const
also have blocked scope.
// Variable scope is available to the end of the execution of the code.
const constVariable = "John Doe";
console.log(constVariable); // Output: "John Doe"
console.log(window.constVariable); // Output: undefined
// Block Scope to the function
function() {
const constVariable = "John Doe";
console.log(constVariable); // Output: "John Doe"
}
console.log(constVariable); // Output: undefined
console.log(window.constVariable); // Output: undefined
Redeclaration
Redeclaring a variable during the lifetime of the variable is possible in javascript.
using var keyword
Redeclaration of a var
variable in the same scope is possible. It doesn't throw any error. But the value of the variable is updated as the execution progress. This is not a good method. It will lead to unexpected results in the code execution.
// Redeclaration in same scope
var myName= "John Doe";
console.log(myName); // Output: "John Doe"
...
...
var myName= "jkjaikrishna";
console.log(myName); // Output: "jkjaikrishna"
// Redeclaration in different scope
var myName= "John Doe";
console.log(myName); // Output: "John Doe";
...
...
function sampleFunction() {
var myName = "Sam Cooper";
console.log(myName); //Output: "Sam Cooper"
}
...
...
sampleFunction();
...
...
var myName= "jkjaikrishna";
console.log(myName); // Output: "jkjaikrishna"
using let keyword
let
keyword is introduced in ES6 to avoid the redeclaration of variables in the same scope. But the declaration is possible in different block scopes.
// Redeclaration in same scope
let myName= "John Doe";
console.log(myName); // Output: "John Doe"
...
...
let myName= "jkjaikrishna";
console.log(myName); // Output: Error: Uncaught SyntaxError: Identifier 'myName' has already been declared
// Redeclaration in different scope
let myName= "John Doe";
console.log(myName); // Output: "John Doe";
...
...
function sampleFunction() {
let myName = "Sam Cooper";
console.log(myName); //Output: "Sam Cooper"
}
...
...
sampleFunction();
...
...
let myName= "jkjaikrishna";
console.log(myName); // Output: Error: Uncaught SyntaxError: Identifier 'myName' has already been declared
using const keyword
const
variables are immutables. So redeclaration and value reassigning are not allowed in the same scope. For different scopes it's possible.
// Redeclaration in same scope
const myName= "John Doe";
console.log(myName); // Output: "John Doe"
...
...
const myName= "jkjaikrishna";
console.log(myName); // Output: Error: Uncaught SyntaxError: Identifier 'myName' has already been declared
// Redeclaration in different scope
const myName= "John Doe";
console.log(myName); // Output: "John Doe";
...
...
function sampleFunction() {
const myName = "Sam Cooper";
console.log(myName); //Output: "Sam Cooper"
}
...
...
sampleFunction();
...
...
var myName= "jkjaikrishna";
console.log(myName); // Output: Error: Uncaught SyntaxError: Identifier 'myName' has already been declared
Hoisting
The hot js interview question topic is here!! Hoisting is the JavaScript mechanism where,
variables and function declarations are moved to the top of their scope before code execution to avoid unexpected code breaking in the time of compilation.
using var keyword
The var
keyword variables are hoisted to the top and declare its value as undefined
// Hoisting with undefined value
console.log(myName); // Output: undefined
...
...
const myName= "John Doe";
using let and const keyword
Like var
keyword, it doesn't show undefined
value, Instead of it they throws a Reference Error.
// Hoisting with undefined value
console.log(myName); // Output: ReferenceError: 'myName is not defined'
...
...
let/const myName= "John Doe";
One more thing...
The feature that we don't add in our list is value assigning and reassigning.
For var
variables value assigning and reassigning can be done at any point in the code. This is also similar in the case of let keyword.
But const
is something different in this case. The value to the const
variables should be declared at the time of variable creation and it's can not be changed during code execution.
// declaring a const variable without initializing.
const myName; // Error: Uncaught SyntaxError: Missing initializer in const declaration
...
//Reassigning a value to a const variable.
const myName = "John Doe";
...
myName = "jkjaikrishna"; //Error: Uncaught TypeError: Assignment to constant variable.
Even though push(), pop(), shift() and unshift() in a
const
array is possible.It's Because of theconst
variable stores only the reference to the array starting index.
//push() to a const array.
const fruits= ['mango', 'apple', 'orange'];
fruits.push('strawberry'); //Output: ['mango', 'apple', orange','strawberry'];
//pop() from const array.
const result = fruits.pop(); //Output: ['mango'];
//shift() on const array.
const animals= ['beer', 'wolf', 'tiger'];
const result = animals.shift(); //Output: ['beer'];
animals.unshift('lion'); //Output: ['lion', 'beer', 'wolf', 'tiger'];
Browser Support
All most all the browsers support var
, let
, and const
keywords. You can check it here.
Conclusion
- How can we conclude this topic? It's here!
-
Scope:
var
declarations are function scoped,let
/const
are block-scoped. -
Re-declaration:
var
can be updated and re-declared,let
can be updated, but not re-declared,const
cannot be updated or re-declared. -
Hoisting:
var
is hoisted and initialized asundefined
,let
/const
are hoisted without initialization and return Reference Error.
-
Scope:
Top comments (0)