我的位置:首页 > 前端开发>Javascript

ES6基础入门之let、const

时间:2020-03-24 20:59:00 来源:互联网 作者: 神秘的大神 字体:

以前变量的声明,可以通过var或者直接使用

直接使用相当于往window全局对象上挂了一个属性

 

 

 

 

let和var的主要区别:

let声明的变量只在当前(块级)作用域内有效

let声明的变量不能被重复声明

不存在变量提升 

 

ES6之前的作用域:

全局作用域  函数作用域  eval作用域

 

ES6块级作用域:

所有用花括号包裹的代码块,如:

    if(){}
    for(){}
    switch(){}
    try{}catch(e){}
    {}

 但是不包括对象,如下面这种情况不是块级作用域

var obj={

    
}
{
    var a=1;//不受块级作用域影响
    let b=2;//只作用在块级作用域内
}
console.log(a);
console.log(b);

 

 块级作用域可以嵌套

内层可以访问外层,外层不能访问内层

{
    let a=1;
    {
        let b=2;
        console.log(a);
    }
    console.log(b);
}

 

 

使用let或者const声明的变量,不能再被重新声明

var a=1;
var a;
console.log(a);//1  不会是undefined
var a=2;
console.log(a);//2

let c=1;
let c;//报错

 

let不存在变量提升

var是存在变量提升的,比如下面这段代码

 

 由于变量提升会把声明提前,相当于

 

 因此结果是undefined

 

 

 如果是let,不存在变量提升,因此会报错

 

暂存死区:

 

 

 

 ES6规定,如果在一个作用域中存在let或者const声明的变量,那么会形成一个封闭作用域,因此会拿不到外面的变量

 

 

 

 

 

使用let实现面试常见小例子

生成10个按钮,每次点击弹出1-10

使用var来实现

for(var i=0;i<10;i++){
    (function(i){
        var btn=document.createElement("button");
        btn.innerText=i;
        btn.onclick=function(){
            alert(i);
        }
        document.body.appendChild(btn);
    })(i);
}

使用let来实现(不再需要闭包来实现内部的作用域)

for(let i=0;i<10;i++){
    let btn=document.createElement("button");
    btn.innerText=i;
    btn.onclick=function(){
        alert(i);
    }
    document.body.appendChild(btn);
}

效果

 

const 声明常量-不可改变的量

常量必须在声明的时候赋值

跟let一样,不能重复声明,存在块级作用域,不存在变量提升

但是,当常量为引用类型的时候,是可以被修改的(不能修改引用地址,但是可以修改地址中的值)

对象:

const cyy={
    name:"cyy",
    age:18
}
console.log(cyy);
cyy.name="cyy2";
console.log(cyy);//可以修改引用地址里的值
cyy={};
console.log(cyy);//不能修改引用地址

 

 

数组:

const ARR=[];
ARR.push(1);
console.log(ARR);//可以修改引用里的值
ARR=[];
console.log(ARR);//不可以修改引用地址

 

 

怎么防止常量为引用类型的时候能被修改的情况:

Object.freeze()

const cyy={
    name:"cyy",
    age:18
}
console.log(cyy);
Object.freeze(cyy);//禁止对象常量的值被修改
cyy.name="cyy2";
console.log(cyy);//可以修改引用地址里的值

 

 

const ARR=[];
Object.freeze(ARR);
ARR.push(1);
console.log(ARR);//可以修改引用里的值

 

 

const扩展

ES6之前怎么声明常量

1、假装是常量

var CYY="cyy";

2、给对象设置不可修改的属性

Object.defineProperty

var cyy={};
Object.defineProperty(cyy,"BASE_NAME",{
    value:"cyy",
    writable:false
})
cyy.BASE_NAME="cyy2";
console.log(cyy.BASE_NAME);

可以看到BASE_NAME属性并没有被更改

 

 

同理,如果是在全局范围内定义一个常量,就可以挂载到window上

Object.defineProperty(window,"BASE_NAME",{
    value:"cyy",
    writable:false
})
BASE_NAME="cyy2";
console.log(BASE_NAME);

 

 

但是这样定义的常量,依然可以对属性做修改

Object.defineProperty(window,"BASE_NAME",{
    value:"cyy",
    writable:false
})
BASE_NAME.a=1;
console.log(BASE_NAME.a);

 

 不过看我打印出来的,貌似是不能修改……

 

可以使用Object.seal防止属性被扩展

Object.defineProperty(window,"BASE_NAME",{
    value:"cyy",
    writable:false
})
Object.seal(BASE_NAME);//防止常量的属性被修改
BASE_NAME.a=1;
console.log(BASE_NAME);
console.log(BASE_NAME.a);

 

 

Object.seal能够防止属性被扩展,但是已经存在的属性,值是可以修改的

var cyy={a:1};
Object.seal(cyy);
console.log(cyy);
cyy.b=2;
console.log(cyy);//不能扩展,没有b属性
cyy.a=3;
console.log(cyy);//属性能被修改,a被改变

 

 

如果想要禁止属性被修改,还是使用Object.defineProperty

var cyy={a:1};
//禁止修改cyy对象的a属性
Object.defineProperty(cyy,"a",{
    writable:false
})
Object.seal(cyy);
console.log(cyy);
cyy.a=3;
console.log(cyy);//属性不能被修改

 

 

也就是说,Object.defineProperty和Object.seal结合使用,可以达到Object.freeze的效果

//在ES6之前,封装函数,使得常量不能被修改
//引用类型的常量,属性也不能被修改和扩展
Object.defineProperty(Object,"myfreeze",{
    value:function(obj){
        for(var i in obj){
            if(obj.hasOwnProperty(i)){
                Object.defineProperty(obj,i,{
                    writable:false
                })
            }
        }
        Object.seal(obj);
    }
})

const cyy={a:1};
Object.myfreeze(cyy);

 

 

hasOwnProperty 判断属性是原型上的属性,还是自身的属性

var obj1={
    a:1,
    b:2
}
var obj2=Object.create(obj1);
obj2.c=3;
obj2.d=4;

//for in遍历到了所有属性,有原型上的a和b属性,还有自身的c和d属性
for(var i in obj2){
    console.log(obj2[i]);
}

//hasOwnProperty 只会显示自身的属性(不包括原型属性)
for(var i in obj2){
    if(obj2.hasOwnProperty(i)){
        console.log(obj2[i]);        
    }
}

 

 

数组使用自定义的仿freeze方法

//在ES6之前,封装函数,使得常量不能被修改
//引用类型的常量,属性也不能被修改和扩展
Object.defineProperty(Object,"myfreeze",{
    value:function(obj){
        for(var i in obj){
            if(obj.hasOwnProperty(i)){
                Object.defineProperty(obj,i,{
                    writable:false
                })
            }
        }
        Object.seal(obj);
    }
})

const cyy=[];
Object.myfreeze(cyy);

 

 

但是,如果对象的属性值又是一个对象的话,那这个对象的属性值还是可以被修改的

//在ES6之前,封装函数,使得常量不能被修改
//引用类型的常量,属性也不能被修改和扩展
Object.defineProperty(Object,"myfreeze",{
    value:function(obj){
        for(var i in obj){
            if(obj.hasOwnProperty(i)){
                Object.defineProperty(obj,i,{
                    writable:false
                })
            }
        }
        Object.seal(obj);
    }
})

var cyy={
    name:"cyy",
    age:18,
    num:{
        a:1,
        b:2
    }
}
Object.myfreeze(cyy);

 

 

 

需要使用递归来解决

//在ES6之前,封装函数,使得常量不能被修改
//引用类型的常量,属性也不能被修改和扩展
Object.defineProperty(Object,"myfreeze",{
    value:function(obj){
        for(var i in obj){
            if(obj.hasOwnProperty(i)){
                Object.defineProperty(obj,i,{
                    writable:false
                })
            }

            //如果属性值是对象,则再次进行遍历
            if(obj[i] instanceof Object){
                Object.myfreeze(obj[i]);
            }
        }
        Object.seal(obj);
    }
})

var cyy={
    name:"cyy",
    age:18,
    num:{
        a:1,
        b:2
    }
}
Object.myfreeze(cyy);