ES6-let和const、块级作用域干货

let命令

基本用法

• let声明的变量只在其所在代码块中有用

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

• 被let声明的变量，每一次循环时都是一个新的变量。关于变量可以记住上一轮循环的值，是因为JavaScript引擎内部会记住上一轮循环的值，初始化本轮的变量时，会在上一轮循环的基础上计算。

• for循环中，设置循环变量的部分是一个父级作用域，循环体内部是一个单独的子作用域。

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

不存在变量提升

使用var关键字声明的变量，会在所有代码执行之前被声明，但不会被赋值；使用let声明的变量不存在变量提升。

console.log(a);  //undefined
var a =2;

console.log(b); //报错
var b = 2;                 

暂时性死区

• 存在let命令的块级作用域，会对let声明的变量形成封闭作用域，如果声明前使用变量会报错。

  var tmp = 123
  if(true){
      tmp = 456 //报错 ReferenceError: tmp is not defined
      let tmp
  }
  

• 也意味着typeof不再是一个百分百安全的操作，如果在let声明前使用变量就会报错。

• 暂时性死区指的是变量作用域中变量声明之前的区域

• 暂时性死区的本质是，只要进入当前作用域，所要使用的变量就已经存在，但是不可获取，只有等到声明变量的代码出现，才可以获取和使用该变量。

不允许重复声明

let不允许在同一个作用域重复声明同一个变量，不能在函数内部重新声明参数。

块级作用域

为什么需要

• ES5只有全局作用域和函数作用域，没有块级作用域
• 使用var会导致内层变量可能会覆盖外层变量
• 使用var会导致用来计数的循环变量泄露为全局变量。

var和let作用域对比

var声明的变量具有函数作用域，let声明的变量具有块级作用域，我们使用嵌套for循环来进行对比：

//1.var声明变量，使用相同的变量名
var words = ["function","scope"]
for(var i = 0;i < words.length; i++){
    var word = words[i]
    for(var i = 0; i < word.length; i++){
        var char = word[i]
        console.log('char',i,char)
    }
}
console.log(i) //输出2（循环变量泄露为全局变量）
//内循环结束时 i= 7，会导致外循环停止（内层变量覆盖外层变量）
/*
 char 0 f
 char 1 u
 char 2 n
 char 3 c
 char 4 t
 char 5 i
 char 6 o
 char 7 n
 */

//2.var声明变量，使用不同的变量名
var words = ["function","scope"]
for(var i = 0;i < words.length; i++){
    var word = words[i]
    for(var j = 0; j < word.length; j++){
        var char = word[j]
        console.log('char',j,char)
    }
}
console.log(i) //输出2（循环变量泄露为全局变量）
/*
char 0 f
char 1 u
char 2 n
char 3 c
char 4 t
char 5 i
char 6 o
char 7 n
char 0 s
char 1 c
char 2 o
char 3 p
char 4 e
 */

//3.let声明变量，变量名相同
let words = ["function","scope"]
for(let i = 0;i < words.length; i++){
    let word = words[i]
    for(let i = 0; i < word.length; i++){
        let char = word[i]
        console.log('char',i,char)
    }
}
console.log(i)//循环变量不会泄露，报错：ReferenceError: i is not defined
/*
char 0 f
char 1 u
char 2 n
char 3 c
char 4 t
char 5 i
char 6 o
char 7 n
char 0 s
char 1 c
char 2 o
char 3 p
char 4 e
 */

块级作用域与立即执行匿名函数

//块级作用域
let read,write
//开启独立块
{
  let data = {}
  write = function (key,val) {
    data[key] = val
  }
  read = function (key) {
    return data[key]
  }
}
//关闭独立块
write('message','Welcome to ES6!')
read('message')
console.log(data) //ReferenceError: data is not defined

//立即执行匿名函数
var read,write
//立即执行匿名函数
(function () {
  {
    var data = {}
    write = function (key, val) {
      data[key] = val
    }
    read = function (key) {
      return data[key]
    }
  }
}())
write('message','Welcome to ES6!')
read('message')
console.log(data) //ReferenceError: data is not defined

ES6的块级作用域

• 只能在let声明的变量所在块内访问变量
• 允许块级作用域的任意嵌套
• 外层作用域无法读取内层作用域的变量
• 内层作用域可以定义外层作用域的同名变量
• 使广泛使用的立即执行匿名函数（IIFE）不再必要

函数声明

针对ES6的浏览器的三条规则：

• 允许在块级作用域内声明函数
• 函数声明类似于var，即会提升到全局作用域或函数作用域的头部
• 函数声明还会提升到所在的块级作用域的头部

在浏览器的ES6环境中，块级作用域内声明函数的行为类似于var声明变量。

注意：避免在块级作用域内声明函数，如果确实需要，就写成函数表达式的形式，允许声明函数的规则只在使用大括号的情况下成立

const命令

基本用法

• 声明一个只读的常量
• 声明时必须赋值
• 只在声明所在的块级作用域内有效
• 声明的常量存在暂时性死区
• 常量不可以重复声明

本质

• const实际上保证的并不是变量的值不得改动，而是变量指向的那个内存地址不得改动
• 对于简单数据类型，变量指向的内存地址中保存的是值，因此等同于常量
• 对于复杂数据类型，变量指向的内存地址保存的是指针，数据结构是可变的

阅读《ES6标准入门》和《ES2015/2016编程实战》读书笔记