let const剖析

蔚落 2022-11-20 09:33 19阅读 0赞

# let cosnt剖析 #

故心故心故心故心小故冲啊

--------------------

### 文章目录 ###

*  let cosnt剖析
 *  一、let剖析
 *  二、const剖析
 *  总结

--------------------

# 一、let剖析 #

//声明变量 var let
        //1、let不存在变量提升
        console.log(a);  //a is not defined
        let a = 1;
    
        //2、同一个作用域内不能重复定义同一个名称
        let a = 10;
        if(true){ 
            let a = 30;  
            //let a = 40;
        };
        //let a = 20;
        console.log(a);  //Identifier 'a' has already been declared
    
        //3、let 块级作用域{} 有着严格的作用域 (var为函数作用域)
        function fun(){ 
            let a = 10;
            if(true){ 
                let a = 20;
            };
            console.log(a)   //10
        };
        fun()
    
        function f(i){ 
            let i = 10;
            console.log(i)  //Identifier 'i' has already been declared
        };
        f(100);
    
        //4、块级作用域的重要性
        for(var i = 0;i<5;i++){ }
        //var i=0; var i = 1; var i = 2....var i = 5;
        //i在外面打印 最后是5 
        console.log(i);  
    
        for(let i = 0;i<5;i++){ }
        console.log(i);  //i is not defined let的块级作用域{} i在外面所以找不到
    
        var arr = [];
        for(let i=0; i<5; i++){ 
            arr[i] = function(){ 
                console.log(i)
            }
        };
        arr[4]();   //4
       
    
        //暂时性死区
        //坑1
        function f(i){ 
            let i = 10;
            console.log(i)  //Identifier 'i' has already been declared
        };
        f(100); //这里的形参相当于在函数作用域内var i =100;
        
        //坑2
        function fun(){ 
            let a = 10;
            if(true){ 
                 a = 20; 
                 console.log(a);
                 let a;  //只要在块级作用域下let来声明，在当前作用域下不能声明同样的名称
            };
        };
        fun()
        //坑3
        let a = b, b = 100; 
        function f(){ 
            console.log(a,b)  //b is not defined
        }
        f();

# 二、const剖析 #

//const更加严格 不仅拥有let的所有要求 还有以下要求
     //1.const声明一个只读的常量。一旦声明，常量的值就不能改变。
     //保持let的不存在变量提升，同一个作用域内不能重复定义同一个名称，有着严格的作用域；
        const x = 12345;
        x = 999;  //error
    
        const y;  //2.const一旦声明变量，就必须立即初始化，不能留到以后赋值。
    
        var a = 10;
        let b = 20;
        const a = 100;  //error
        const b = 200;  //error
    
        //const 的坑
        //常量obj储存的是一个地址，这个地址指向一个对象。不可变的只是这个地址，即不能把obj指向另一个地址，
        //但对象本身是可变的，所以依然可以为其添加新属性。
        const obj = { };
        obj.name = 'abc';
        obj['age'] = 18;
        console.log(obj);  //{ name: 'abc', age: 18 }
        
        obj = { id:10} ; //obj指向另一个地址
    
        //常量arr是一个数组，这个数组本身是可写的，但是如果将另一个数组赋值给arr，就会报错。
        const arr = [];
        arr.push(1);
        arr[1] = 2;
    
        arr = ['a'] //但是如果将另一个数组赋值给arr，就会报错

# 总结 #

let  
  
1.let不存在变量提升  
2.let同一个作用域内不能重复定义同一个名称  
3.let 块级作用域 有着严格的作用域 \{\}  
4.let暂时性死区

const  
  
1.let的所有要求  
2.const声明一个只读的常量。一旦声明，常量的值就不能改变  
3.const一旦声明变量，就必须立即初始化，不能留到以后赋值