Variable hoisting is a behavior in JavaScript where variable declarations are moved to the top of their respective scope, regardless of where the actual declaration occurs in the code. This means that variables can be used before they are declared, but they will have an initial value of undefined. Here's an example of variable hoisting: 

function foo() {
  console.log(x); // logs 'undefined'
  var x = 10;
  console.log(x); // logs '10'
}

foo();
In this example, we've defined a function foo that logs the value of variable x before and after it is declared and assigned a value of 10. Even though x is used before it is declared, JavaScript will hoist the declaration to the top of the function, so it will be available throughout the function with an initial value of undefined. It's important to note that variable hoisting only applies to variable declarations, not to variable assignments. This means that if you try to use a variable before it is declared and assigned a value, you will still get a ReferenceError. Here's an example: 

function bar() {
  console.log(y); // ReferenceError: y is not defined
  y = 20;
  console.log(y); // logs '20'
}

bar();
In this example, we're trying to use variable y before it is declared. However, since there is no variable declaration for y, JavaScript will throw a ReferenceError. If we remove the first console.log statement and run the function again, we will see that y is assigned a value of 20. It's generally good practice to declare all variables at the top of their respective scope to avoid confusion and errors due to variable hoisting. This can be achieved using the let and const keywords, which have block scope and do not exhibit variable hoisting. It's important to understand that variable hoisting only applies to variables declared with the var keyword. Variables declared with let and const are also hoisted but have a different behavior known as the "temporal dead zone" (TDZ). In the TDZ, accessing variables before their declaration results in a ReferenceError. This behavior ensures that variables declared with let and const are not accessible before they are explicitly declared in the code. Please find the detailed explanation here