Understanding variable scopes in Javascript

In JavaScript, there are two types of scopes

1. Global Scope – Scope outside the outermost function attached to Window
2. Local Scope – Inside the function being executed

Let’s look at the code below. We have a global variable defined in first line in global scope. Then we have a local variable defined inside the function fun().

When we execute the function fun(), the output shows that both global as well as local variables are accessible inside the function as we are able to console.log them. This shows that inside the function we have access to both global variables (declared outside the function) and local variables (declared inside the function).Let’s move the console.log statements outside the function and put them just after calling the function.

We are still able to see the value of global variable, but for local variable console.log throws an error. This is because now the console.log statements are present in global scope where they have access to global variables but cannot access the local variables.

Word of caution: Whenever you are declaring variables, always use the prefix var. If you don’t use the var keyword, then the variables are by default created in the global scope. For instance, in the above example, let’s just remove the keyword var before the declaration of localVar.

We are now able to console.log the local variable as well because the localVar was created in the global scope as we missed the keyword var while declaring it. What really happened is that as we didn’t use the var keyword, JavaScript first searched the localVar in local scope, then in the global scope. As there was no existing global variable by that name, so it created a new global variable.One of the most asked questions in interviews is the scenario where the global as well as local variable has the same name. Let’s see what happens then.In this example, we have the declared a local as well as global variable “name”. What matters here is the scope in which we are accessing it. In the above example, we are accessing it in global scope, so it will output the global variable as local variable is not present in its scope.Let’s move the console.log statement inside the function fun().Inside the function fun(), both the local as well as global variables are accessible. But when we console.log the variable name, firstly JavaScript tries to find a local variable in the current scope. It finds the local variable and outputs it. Otherwise it would have search for the variable “name” in the outer scope (which in this case is global scope).

What if we want to access the global variable instead of local one here. Well, the window object comes to our rescue. All the global variables are attached to window object and thus we can access the global variable name as shown in example below.

After discussing about scopes in JavaScript, guessing the output of below code fragments should be a cakewalk.

In the first example as we didn’t use the keyword var, the variable “i” was assumed to be declared in global scope and thus the output was 100. In the second example, “i” became a local variable and thus was not accessible outside the scope of that function.

Let’s look at another example.Well, the output should have been a ReferenceError, right? Wrong! The if block does not create a new scope in JavaScript. Only a new function creates a new scope. Always remember, JavaScript has function scope and not block scope. So in the above example, all the code inside the function fun() is in the same scope and thus the output is 100.

After understanding the concept of scopes in JavaScript, let’s look at practical example of these concepts. Suppose you want to implement something like “private variables of class in C++/Java” in JavaScript. Checkout the code snippet below for the exact code you would need to write.

In the above code, you have a variable “name” which acts as a private variable as it is not directly accessible outside the scope of function person(). But the variable “name” is accessible by the functions inside the scope of function person(). This lets us create the getter and setter function to access the variables, thereby implementing the data hiding concept of classes in OOPS.

About the author:

“Harshit is a technology enthusiast and has keen interest in programming. He holds a B.Tech. degree in Computer Science from JIIT, Noida and currently works as Front-end Developer at SAP. He is also a state level table tennis player. Apart from this he likes to unwind by watching movies and English sitcoms. He is based out of Delhi and you can reach out to him at https://in.linkedin.com/pub/harshit-jain/2a/129/bb5

If you also wish to showcase your blog here, please see GBlog for guest blog writing on GeeksforGeeks.