✈ var

🚗 a few small examples

var a=10;
var a=20;
console.log(a)// a result of 20 indicates that the declaration can be repeated and the value changes
Copy the code
console.log(a)// The result is underfind
var a=50;
// Indicates that the variable declared by var has a declaration promotion. Use can precede declaration
Copy the code
 var a = [];
    for (var i = 0; i < 10; i++) {
      a[i] = function () {
        console.log(i);// Result is 10
      }
    }
    a[5] ();Copy the code

Summary: We can find from the abovevarDeclared variables have their strengths and weaknesses, so Es6 has added a commandletIs also used to declare variables

✈ let

🚗 a few small examples

/* Example: 1*/
    let a = 10;
    let a = 20;// result: error, Identifier 'a' has already been declared
    console.log(a);
Copy the code
    console.log(a);// Error: Cannot access 'a' before initialization
    let a = 10;
Copy the code
The first linelet a = 10; The second lineif (true) {third lineconsole.log(a);// Error: 'a' cannot be accessed before initialization.In the fourth rowlet a = 30; // block-level scopeLine 5} line 6console.log(a);/ / 10
Copy the code

In the last small example, we found that we had already defined a, so why would printing a after it give an error? There are two concepts to mentionTemporary dead zoneandBlock-level scope

🚑 temporary dead zones and block-level scopes

Block-level scope: With the let statement after a variable, if there are any {} can form a scope, we call this area within the {} block level scope, as we are in the first line declares the let a = 10 in the second to the fifth line has a block-level scope, so run to here, we want to be in this block level scope will be an error in the a group. Why do you need block-level scopes?

Case one: the inner variable may override the outer variable case two: the counter variable in the loop becomes a global variable.Copy the code

Temporary dead zone: As long as a variable is declared with let in a block-level scope, the variable is bound to that scope and is available only in that scope.

✈ Var and let comparison

  1. letThere is no declaration promotion and an error will be reported if called before the declaration;varCan be called before declaration with the value undefined.
  2. letDuplicate declarations are not allowed (as shown in Example 1 above),varYou can reread the statement.
  3. letBe careful when using itTemporary dead zones and block-level scoping issues

✈ const

Const is used the same way as let.

Similarities:

  • There is no claim promotion
  • Temporary dead zone
  • Block-level scope
  • Duplicate declarations are not allowed.

Difference:

  • Const is used to declare constants; A variable declared by const must be assigned a value that cannot be changed
 let a;
    a = 10;
    const b; //Missing Initializer in const declaration The variable declared by const is not initialized.
    const b = 20;
    b = 30;/ / an error!
    console.log(b);
Copy the code
    const arr = [10.20.30];
    arr.push(40);
    console.log(arr);
Copy the code

✔ summary

  • A variable defined by const that stores a value of a complex data type is not modified as long as the address is unchanged.
  • For general useletandvarConst is often used to fetch element nodes, introduce modularity, etc.