Javascript Let Vs. Var: What Are The Differences?

Until the introduction of the ES6 specification, Javascript programmers were used to declaring each variable with the keyword var, the only one available at the time. With ES6, in any case, two new watchwords have been presented, let and const, which include a few distinctions being used. So how about we find in more detail the qualities of let versus var in Javascript?

Local Or Global Scope: What’s The Difference?

First, let’s clarify the concept of scope, where a variable or a constant can act in a specific part of code. Indeed, the scope is one of the main differences between let and var.

Local Scope

The local scope refers only to a particular block, the lines between two curly brackets {}. Therefore, constants and variables declared within a block have a local scope. When we use the const or let keywords indicate constants or variables, they will only work in the block in which they are declared. Instead, they are inaccessible outside the block in question.

Global Scope

A variable or constant declared outside a function and not limited by braces {} in a block has global scope. They are, therefore, accessible and usable in the script globally. Note that variables declared within a block take precedence over globally scoped ones. As we will see, the let keyword can prevent the local variable from overriding a global variable.

Let Vs. Var In Javascript

As already mentioned, before the advent of ES6, it was possible to declare variables only with the var keyword. ES6 presented the new const and allowed catchphrases to proclaim constants and factors. The catchphrase const, as you can undoubtedly figure, is utilized to proclaim a steady, that is to say, a variable that can’t be reassigned. Its degree is restricted to the block where it is proclaimed. We should investigate the particular distinctions in the catchphrases for variations, i.e., let versus var in Javascript.

The Keyword Let

The let keyword is used to declare variables related to the block within which it appears. Declaring a variable with let limits the scope to that specific block. This implies that it won’t abolish worldwide factors and won’t be available using the window object. If we attempt to review a variable demonstrated with the external block in which it is found, we will get a Reference mistake message on the control center. Moreover, factors pronounced with let can’t be re-proclaimed inside a similar degree yet just in various blocks.

The keyword Var

A variable declared through the var keyword is not limited to the block but can be used within its function. The variable, therefore, has a function scope. For this situation, the variable can be called external, the block in which it is announced, as it isn’t restricted to the block’s extension. It likewise has a worldwide extension, being open through the window object. Dissimilar to the let variable, the var variable can be re-pronounced inside a similar degree. In this situation, the principal worth will be supplanted.

Hoisting Of Let Vs. Var In Javascript

Lifting alludes to JavaScript conduct that permits factors to be utilized before they are announced. This is valid for factors shown with the var catchphrase, which are available at the highest point of the block of code they are in, albeit as a general rule, they may be proclaimed further down. In any case, this doesn’t have any significant bearing on factors determined with the let watchword. These are not instituted before the actual statement, and attempting to involve them before the line of code in which they seem will bring about a Reference mistake.

Summary Of The Differences Between Let Vs. Var In Javascript

In conclusion, there are four main differences in declaring variables with let vs. var in Javascript, namely:

1. The scope: while the let keyword creates a variable whose scope is tied to the block in which it is declared, the var keyword creates a function-scoped variable;
2. The re-declaration of a variable is impossible within the same scope using the let keyword, which would otherwise create a Reference error to the console. With the var keyword, on the other hand, you have more flexibility, and you can re-declare the variable without problems;
3. Hoisting: let variables cannot be used before the line in which they are declared, while var variables are initialized at the beginning of the block in which they appear;
4. Global properties: if the variable var is used outside of a function, it creates a global variable accessible through the window object, which is not the case with the let variable.

Also Read: The Benefits Of An ERP Framework