Answers for "let and var difference"

difference between var and let

var is function scoped and let is block scoped. Let's say you have:
function understanding_var() {
	if (1 == 1) {
    	var x = 5;
        console.log('the value of x inside the if statement is ' + x);
    }
    console.log(x);
} 
//output: the value of x inside the if statement is 5
		  5

function understanding_let() {
	if (1 == 1) {
    	let x = 5;
        console.log('the value of x inside the if statement is ' + x);
    }
    console.log(x);
} 
//output: the value of x inside the if statement is 5
		  Uncaught ReferenceError: x is not defined
          
var is defined throughout the entire function, even if it's inside the if 
statement, but the scope of let is always within the curly braces, not outside
it, even if the conditional statement is inside the function.

Difference between let and var in javascript

let a = 'hello'; // globally scoped
var b = 'world'; // globally scoped
console.log(window.a); // undefined
console.log(window.b); // 'world'
var a = 'hello';
var a = 'world'; // No problem, 'hello' is replaced.
let b = 'hello';
let b = 'world'; // SyntaxError: Identifier 'b' has already been declared

let and var difference

function run() {
  var foo = "Foo";
  let bar = "Bar";

  console.log(foo, bar);

  {
    let baz = "Bazz";
    console.log(baz);
  }

  console.log(baz); // ReferenceError
}

run();

let vs var

// var is function-scoped, so redeclaring it in a block will cause its value outside the block to change as well:

var one = 'one: declared outside the block';

if (true === true) {
  var one = 'one: declared inside the block'; // notice: we redeclare 'one' here
  console.log(one); // prints 'one: declared inside the block'
}

console.log(one); // also prints 'one: declared inside the block', because the variable was redeclared in the 'if' block. The outer 'var' variable was therefore destroyed and replaced by inner var variable.

// 'let' is block-scoped, so redeclaring a 'let' variable inside of a block creates a different 'let' variable with the same name whose scope is inside the block:

let two = 'two: declared outside the block';

if (true === true) {
  let two = 'two: declared inside the block';
  console.log(two); // prints 'two: declared inside the block'
}

console.log(two); // prints 'two: declared outside the block', because two declared inside the block is a separate variable. The 'let' variables are unrelated and therefore are unaffected by each other.

what to use let vs var js

/* DIFFERENCE BETWEEN LET AND VAR */

//LET EXAMPLE
{
  let a = 123;
};

console.log(a); // undefined

//VAR EXAMPLE
{
  var a = 123;
};

console.log(a); // 123

difference between var and let in javascript

/*

Therefore, 
  
  var:
    -can be declared outside any function to be used inside any function
    -can be declared inside any function or any other {} which are of only if or if-else or switch etc. and can be used anywhere inside the function
    -can be changed again and again anywhere
  let:
    -can be declared outside any function to be used inside any function
    -if declared inside any function or any other {} which are of only if or if-else or switch etc. and can't be used anywhere inside the function and can be only used inside statement
    - can be changed again and again only inside the statement in which they are made in
    const:
    -can be declared outside any function to be used inside any function
    -can be declared inside any function or any other {} which are of only if or if-else or switch etc. and can be used anywhere inside the function
    -cannot be changed again and agan anywhere, if tried to, will result in an error

*/
// var has function scope. (this variable can be accssed from anywhere inside function)
// let & const has block scope.(this variable can not be accessed out of block. means outside of if else but inside of a function it can not be accessed. only inside that block we can access this variable)
// https://www.youtube.com/watch?v=--Vh17ocC_s
function func(){
  if(true){
    var A = 1;
    let B = 2;
  }
  A++; // 2 --> ok, inside function scope
  B++; // B is not defined --> not ok, outside of block scope
  return A + B; // NaN --> B is not defined
}
//example 2
var variable1 // declared using var
const variable2 // declared using const

myFunction1();

function myFunction1() {
  variable1 = "hello!";
  console.log(variable1);
  // "hello!"
}

myFunction2();

function myFunction2() {
  variable2 = "hello!";
  // error: variable2 is a constant and can not be redifined
}

myFunction3(true);

myFunction3(codition) {
  if(condition) {
    let variable3 = "helo!" // declared using const
  }
  variable3 = "hello!";
  // error: variable3 is out of scope
}