let和const命令_let a=5;是什么-CSDN博客

本文链接：https://blog.csdn.net/MatheoGao/article/details/103735893

let命令

基本使用

ES6中新增了一个变量声明的命令let，let的使用方法与我们之前使用的var十分相似,但是let和var的作用域不同，var可以说没有作用域限制，let只能在当前代码块方位内使用。

{
      let a = 5;
      var b = 10;
}
console.log(a);      // Uncaught ReferenceError: a is not defined
console.log(b);     // 10

在上面代码块中通过let和var命令分别声明了变量a,b,在代码块外分别调用两个变量时，变量a报错，b可以正常输出10.这是因为let声明的变量只能在代码块中使用。
并且在代码块中必须先声明后使用，否则就会报错。
下面通过for循环来更好的说明let命令作用域的作用。

for(let i=0;i<3;i++){
}
console.log(i);
//ReferenceError: i is not defined

这个代码说明i只能在for循环中使用，在循环外就会报错。
再看下面这个例子：

var a = [];
for (var i = 0; i < 10; i++) {
    a[i] = function () {
        console.log(i);
    };
}
a[6]();  //10

这段代码输出的结果是10，这是因为变量i是用var声明的，是一个全局变量，每次循环都会改变，而循环内被赋给数组a的函数内部的console.log(i)，里面的i指向的就是全局的i。也就是说，所有数组a的成员里面的i，指向的都是同一个i，导致运行时输出的是最后一轮的i的值，也就是 10。
如果使用let声明变量i的话，每次循环都会有新的i产生，因此a[6]=6;

var a = [];
for (let i = 0; i < 10; i++) {
    a[i] = function () {
        console.log(i);
    };
}
a[6]();  //10

上面代码中，变量i是let声明的，当前的i只在本轮循环有效，所以每一次循环的i其实都是一个新的变量，所以最后输出的是6。你可能会问，如果每一轮循环的变量i都是重新声明的，那它怎么知道上一轮循环的值，从而计算出本轮循环的值？这是因为 JavaScript 引擎内部会记住上一轮循环的值，初始化本轮的变量i时，就在上一轮循环的基础上进行计算。
let命令在for循环中声明变量还有一个特别之处：

for (let i = 0; i < 3; i++) {
    let i = 'aaa';
    console.log(i);
}

以上代码块执行结果：控制台输出了三次aaa，这个说明设置循环的部分和循环内的部分不是同一个作用域，也就是设置循环变量的那部分是一个父作用域，而循环体内部是一个单独的子作用域。
##### 不允许重复声明
let命令不允许在同一代码块中重复声明某一变量.

function add(){
    let a = 5;
    let a = 6;
}
//SyntaxError: Identifier 'a' has already been declared

因此也不能在函数内部重新声明参数

function add(a){
let a = 5;
}
//SyntaxError: Identifier 'a' has already been declared

但是下面这种情况可以，因为函数内部又重新实现了一个代码块，相当于函数的子作用域，因此在子作用域中重新声明是可以实现的。

function add(a){
   {
     let a = 5;
   }
}
//不报错

##### 不存在变量提升
var声明变量会发生"变量提升"，即声明变量在使用变量之后，值为undefined。这种情况与我们平时出现的情况逻辑格格不入，应该是先声明后使用，因此为了纠正这种情况，let命令的语法规定，必须是先声明后使用，否则就会报错。

console.log(a);     //undefined
var a = 3;     
console.log(b);    //ReferenceError: Cannot access 'b' before initialization
let b = 5;

上面代码中，a是通过var进行声明的，会发生变量提升，在脚本运行是就已经存在，只是没有值，因此会在控制台中打印undefined，而b是let声明，不会发生变量提升，因此就会报错。
#####暂时性死区
在块级作用域中，let声明的变量就会值存在这个区域中，不会收外部环境的影响。

let temp = 'AAA';
{
    console.log(temp);
    let temp = 'BBB';  //报错
}

这段代码报错的原因就是因为，存在全局变量temp，但是在代码块中有声明了temp，并且这个temp只在该代码块中起作用，由于无法进行变量提升，因此在打印temp时就会报错。
总之，在代码块内，使用let命令声明变量之前，该变量都是不可用的。这在语法上，称为“暂时性死区”（temporal dead zone，简称 TDZ）。

if(true){
    //TDZ 开始
    a = 'abc';
    console.log(a);    //报错
    let a;    //TDZ结束
    console.log(a);   //undefined
    a = 123;
    console.log(a);   //123
}

上面代码在let声明变量a之前都属于“暂时性死区”，因此在使用时要特别注意，任何变量必须在let声明后才可使用。
但是，有些“死区”是比较隐蔽的，比如：

function add(x=y,y=2){
    return [x,y];
}
add();

上面代码调用add函数出错(有的不一定出错)，是因为参数x的默认值是另一个参数y，但是参数y还没有声明，因此会形成“死区”进而报错。如果y的默认值是x的话就不会，报错，因为x已经在之前声明过了。

// 不报错
var x = x;
// 报错
let x = x;
// ReferenceError: x is not defined

上面代码报错，也是因为暂时性死区。使用let声明变量时，只要变量在还没有声明完成前使用，就会报错。上面这行就属于这个情况，在变量x的声明语句还没有执行完成前，就去取x的值，导致报错”x 未定义“。
ES6 规定暂时性死区和let、const语句不出现变量提升，主要是为了减少运行时错误，防止在变量声明前就使用这个变量，从而导致意料之外的行为。只要在书写时注意点就没事。

块级作用域

使用块级作用域？

1. 可以避免内部变量覆盖外部变量，即内部变量由于变量提升，将外部变量覆盖。
2. 避免循环变量泄露为全局变量，即for循环中控制次数的变量并没有在循环完后消失，而是继续存在，成为全局变量。
##### ES6的块级作用域

function add(){
    let a = 5;
    {
        let a = 7;
    }
    console.log(a);
}
add();

上面的函数有两个代码块，都声明了变量a，运行后输出 5。这表示外层代码块不受内层代码块的影响。如果两次都使用var定义变量a，最后输出的值才是 10。
ES6中块级作用域可以随意嵌套：

{{{{
    {let a = 'Hello ES6';}
    console.log(a);   //报错
}}}}

上面代码中嵌套了五层块级作用域，每一层都是一个单独的作用域，因此四层无法获取到五层中let声明的变量a，但是，内部作用域和外部作用域声明的变量名称可以一致。
块级作用域的出现，实际上使得获得广泛应用的匿名立即执行函数表达式（匿名 IIFE）不再必要了。

// IIFE 写法
(function () {
  var tmp = ...;
  ...
}());
// 块级作用域写法
{
  let tmp = ...;
  ...
}

const命令

基本用法

const命令声明的是常量，一旦声明就不允许进行修改(咱们学习过其他的语言的肯定知道常量)。

const a = '2222';
a = 3333;  //TypeError: Assignment to constant variable.

上面的例子是由于修改常量造成的报错。
const声明的变量不得改变值，这意味着，const一旦声明变量，就必须立即初始化，不能留到以后赋值。
const只是声明不对对象进行赋值也是会报错的。
const的语言基本和let一致，也是无法进行重复声明，不存在变量提升，也有暂时性死区等。
const实际上保证的，并不是变量的值不得改动，而是变量指向的那个内存地址所保存的数据不
得改动。对于简单类型的数据（数值、字符串、布尔值），值就保存在变量指向的那个内存地
址，因此等同于常量。但对于复合类型的数据（主要是对象和数组），变量指向的内存地址，
保存的只是一个指向实际数据的指针，const只能保证这个指针是固定的（即总是指向另一个固
定的地址），至于它指向的数据结构是不是可变的，就完全不能控制了。因此，将一个对象声
明为常量必须非常小心。

Object.freeze
const foo = Object.freeze({});
// 常规模式时，下面一行不起作用；
// 严格模式时，该行会报错
foo.prop = 123;

上面代码中，常量foo指向一个冻结的对象，所以添加新属性不起作用，严格模式时还会报错。
除了将对象本身冻结，对象的属性也应该冻结。下面是一个将对象彻底冻结的函数。

var constantize = (obj) => {
  Object.freeze(obj);
  Object.keys(obj).forEach( (key, i) => {
    if ( typeof obj[key] === 'object' ) {
      constantize( obj[key] );
    }
  });
};