[ES6] let 、 const

#

let
let var1 [= value1] [, var2 [= value2]] [, ..., varN [= valueN]];

声明了一个块级域的本地变量，并且可以同时初始化该变量。

let 允许把变量的作用域限制在块级域中。与 var 不同处是：var 申明变量要么是全局的，要么是函数级的，而无法是块级的。

 

在用到内部函数的时候，let 能够让代码更简洁

var list = document.getElementById("list");

for (var i = 1; i <= 5; i++) {
  var item = document.createElement("LI");
  item.appendChild(document.createTextNode("Item " + i));

  let j = i;
  item.onclick = function (ev) {
    console.log("Item " + j + " is clicked.");
  };
  list.appendChild(item);
}

 

与var不同，let是块级

function varTest() {
  var x = 31;
  if (true) {
    var x = 71;  // same variable!
    console.log(x);  // 71
  }
  console.log(x);  // 71
}

function letTest() {
  let x = 31;
  if (true) {
    let x = 71;  // different variable
    console.log(x);  // 71
  }
  console.log(x);  // 31
}

#

//关键点还是块级
if(a<3) {
    let b = 1;
    console.log(b);
}
if(a<3) {
    let b = 2;
    console.log(b);
}
if(a<3) {
    let b = 3;
    console.log(b);
}

 

#

var a = 5;
var b = 10;

if (a === 5) {
  let a = 4; // The scope is inside the if-block
  var b = 1; // The scope is inside the function

  console.log(a);  // 4
  console.log(b);  // 1
} 

console.log(a); // 5
console.log(b); // 1

全局

var x = 'global';
let y = 'global';
console.log(this.x);//global
console.log(this.y);//global

let 在循环中

for (let i = 0; i<10; i++) {
  console.log(i); // 0, 1, 2, 3, 4 ... 9
}

console.log(i); // i is not defined

let重复定义一个变量将引起 TypeError.

if (x) {
  let foo;
  let foo; // TypeError thrown.
}

#

switch (x) {
  case 0:
    let foo;
    break;
    
  case 1:
    let foo; // TypeError for redeclaration.
    break;
}

暂存死区

function do_something() {
  console.log(foo); // ReferenceError
  let foo = 2;
}

在方法内对同参数名变量声明会报错

 ```

    function xx(a) {
        let a = 2;
        console.log(a)//error
    }
    xx(3);
    function yy(a) {
        var a = 2;
        console.log(a)//2
    }
    yy(3);

```

 

变量提升
```
    console.log(o);//error
    console.log(k);//undefined
    let o = 33;
    var k = 44;

```

const
声明创建一个只读的常量。这不意味着常量指向的值不可变，而是变量标识符的值只能赋值一次。

这个声明创建了一个常量，可以在全局作用域或者函数内声明常量，常量需要被初始化。
在定义常量的同时必须初始化(鉴于常量的值在初始化后就不能改变)。

常量拥有块作用域，和使用let 定义的变量十分相似。常量的值不能通过再赋值改变，也不能再次声明。

一个常量不能和它所在作用域内的其他变量或函数拥有相同的名称。

常量在声明的时候可以使用大小写，但通常情况下会使用全部大写英文。

 

#

const aa = 2;
function cc(){
//console.log(aa);
 const aa = 3;
 console.log(aa);//3
}
cc();
console.log(aa);//2

 

#

// 定义常量MY_FAV并赋值7
const MY_FAV = 7;

// 在 Firefox 和 Chrome 这会失败但不会报错(在 Safari这个赋值会成功)
MY_FAV = 20;

// 输出 7
console.log("my favorite number is: " + MY_FAV);

// 尝试重新声明会报错 
const MY_FAV = 20;

//  MY_FAV 保留给上面的常量，这个操作会失败
var MY_FAV = 20; 

// MY_FAV 依旧为7
console.log("my favorite number is " + MY_FAV);

#

// 下面是一个语法错误
const A = 1; A = 2;

// 常量要求一个初始值
const FOO; // SyntaxError: missing = in const declaration

#

// 常量可以定义成对象
const MY_OBJECT = {"key": "value"};

// 重写对象和上面一样会失败
MY_OBJECT = {"OTHER_KEY": "value"};

// 对象属性并不在保护的范围内，下面这个声明会成功执行
MY_OBJECT.key = "otherValue";

 

#