I've been reading about JavaScript hoisting sometime back.
JavaScript Scoping and Hoisting by Ben Cherry
Two words about “hoisting” by Dmitry Soshnikov
and, some more about JavaScript type-coercion, truth & false test: Truth, Equality and JavaScript and some other resource
And while practicing some, and found I m missing some important concept about the hoisting and a variable' truthy & falsy.
var foo = 1;
function bar() {
if (!foo) {
alert('inside if');
var foo = 10;
}
}
bar();
o/p: inside if
Doubt: 'foo' value being '1', if(!foo)
should evaluates to false
and that block should not be executed (quoting from above resources: hoisting affects only the var
& function
declaration, but not the execution). But why is that alert is shown.
This is not the case if I directly use false
(shown in the below no-tricks code: snippet #3)
var foo = 1;
function bar() {
if (!foo) {
alert('inside if');
}
}
bar();
o/p: no output; means control not entered 'if' block
This is what one could expect
var foo = 1;
function bar() {
if (false) {
alert('inside if');
var foo = 10;
}
}
bar();
o/p: no output; means control not entered 'if' block
This is what one could expect
Someone please clarify. Thanks
In JavaScript, Hoisting is the default behavior of moving all the declarations at the top of the scope before code execution. Basically, it gives us an advantage that no matter where functions and variables are declared, they are moved to the top of their scope regardless of whether their scope is global or local.
Specifically, we discussed how hoisting allows you to refer to JavaScript variables and functions prior to their declaration, and how closures allow you to access function-scoped variables outside of that specific function.
The let and const KeywordsVariables defined with let and const are hoisted to the top of the block, but not initialized. Meaning: The block of code is aware of the variable, but it cannot be used until it has been declared. Using a let variable before it is declared will result in a ReferenceError .
Hoisting is JS's default behavior of defining all the declarations at the top of the scope before code execution. One of the benefits of hoisting is that it enables us to call functions before they appear in the code. JavaScript only hoists declarations, not initializations.
For your example number 1, the alert is shown because you're using var
inside the function and the var
declaration is hoisted to the top of the function, so it is equivalent to:
var foo = 1;
function bar() {
var foo;
if (!foo) {
alert('inside if');
foo = 10;
}
}
bar();
One might conclude that these sorts of issues offer compelling reason to declare all variables explicitly at the top of the function.
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With