ES6中const let 和 暂时性死区

目录

let的使用

a.块级作用域——只有在块里面有用

b.let不允许重复声明,var允许

c.不存在变量提升

d. 暂存性死区（TDZ）---只要在声明之前就使用这些变量，就会报错。

e.let不与顶层对象挂钩,var跟顶层对象挂钩

2.const声明常量

1.常量——不允许被修改，声明的时候必须初始化

2.不能重复定义

3.块级

4.声明不提升

5.不与顶层对象挂钩

let的使用

a.块级作用域——只有在块里面有用

for循环的计数器很适合let命令

// {
    //   var i=100;
    // }
    // console.log(i);//100，可以访问到
    // {
    //   let i=100;//不会污染全局
    // }
    // console.log(i);//报错

    // for(var i=0;i<5;i++){

    // }
    // console.log(i);//5

    var oli=document.querySelectorAll("ul li")
    // var 是全局作用域
    // for(var i=0;i<oli.length;i++){
    //   // 因为是点击，所以是异步
    //   // 解决方案
    //   oli[i].index=i;
    //   oli[i].onclick=function(){
    //     // console.log(i);——每一次打出来的i,都是新的
    //     console.log(this.index);
    //   }
    // }

    for(let i=0;i<oli.length;i++){
      oli[i].onclick=function(){
        console.log(i);//现在每一次点击都是再原来的循环里面的
      }
    }
    ************************************
    for(let i=0;i<3;i++){
    	let i='abc';
        consloe.log(i);
    }
    //abc
    //abc
    //abc
  表明函数内部的变量i与循环变量i不在同一个作用域。

b.let不允许重复声明,var允许

    // var ——后面将前面覆盖
    var a=1;
    var a=2;
    console.log(a);//2
    console.log(("*******************"));

    // let ——报错，提示重复定义
    let a=1;
    let a=2;
    console.log(a);//报错
    console.log(("*******************"));
    
    function funx(arg){
    	let arg;//报错
    }
    
    function func(arg){
    {
    	let arg;//不报错
    }
    }

c.不存在变量提升

 console.log(myname);//正确的，因为var，有变量提升
    var myname="lin";

    console.log(myname);//错误的
    let myname="lin"

d. 暂存性死区（TDZ）---只要在声明之前就使用这些变量，就会报错。

只要块级作用域内存在let命令，它所声明的变量就“绑定”这个区域，不得受到外部的影响。

let myname="wuwu"
    function test(){
      console.log(myname);//报错
      let myname="lin"
    }
    test();//报错

var tmp=123;//全局作用域
if(true){
    tmp='abc';//ReferenceError
    let tmp;
}

在代码块内，使用let命令声明变量之前，该变量都是不可用的。

if(true){
      // TDZ开始
      tmp='abc';//ReferenceError
      console.log(tmp);//ReferenceError

      let tmp;//TDZ结束
      console.log(tmp);//undefined

      tmp=13;
      console.log(tmp);//13
    }

var x=x;//不报错

let x=x;//报错

e.let不与顶层对象挂钩,var跟顶层对象挂钩

 var myage=100;
    console.log(window.myage);//100
    console.log(("*******************"));
    let myage1=100;
    console.log(window.myage1);//undefined

2.const声明常量

1.常量——不允许被修改，声明的时候必须初始化

    const myname="lin";
    myname="linyi";

2.不能重复定义

  const myname="lin";
    myname="linyi";
const myname="lin1"

3.块级

{
      const myname="lin"
    }
    console.log(myname);//外面无法访问

4.声明不提升

 const myname2="lin"
    function test(){
      // 暂时性死区
      console.log(myname2);
      const myname2="lin2"
    }
    test();

5.不与顶层对象挂钩

   const myage=100;
    console.log(window.myage);//undefined

注意点：

const一定不能修改吗？——错误的，如果是复杂数据类型，就可以。因为复杂数据类型存放的是地址。
解决方法：
Object.freeze(冻结方法)——使得复杂数据类型中的数据不能被修改

const实际上保证的并不是变量的值不可以改变，而且变量指向的那个内存地址不可以动。对于简单数据类型来说（数值，字符串，布尔值）来说，值就报错在变量指向的内存地址中，因此等同于常量。
对于复合类型来说（数值、对象）来说，变量指向的是内存地址存储，只是一个指针。

    const myobj={
      name:"lin",
      age:100
    }

    // myobj是指向复杂数据类型的地址
    // myobj="dwa"//报错
    myobj.name="tiechui"//tiechui

 // 为foo添加一个属性，可以成功
    foo.prop=123;
    foo.prop;//123

    // 将prop指向另一个对象，就会报错
    foo={};

 const a=[];
    a.push('Hello');//可以执行
    a.length=0;//可以执行
    a=['Deve'];//报错

解决方法：Object.freeze(冻结方法)——使得复杂数据类型中的数据不能被修改

 const myobj=Object.freeze({
      name:"lin",
      age:100
    })
    myobj.name="lin"
    console.log(myobj);//lin——不能被修改

3.let和const的区别