ES6(二) 变量

ES6

发布日期: 2020-03-11

更新日期: 2020-05-03

文章字数: 2.9k

阅读时长: 11 分

阅读次数:

(一) 本节知识点

let 命令
块级作用域
const 命令
顶层对象的属性
global 对象

(二) LET 知识点汇总

(1) let 命令

ES6 新增了 let 命令，用来声明变量，他的用法类似 var 但是所声明的变量，只是在 let 命令所在的代码块内有效
比如

{
  let a = 10
  var b = 1
}
a //语法错误
b //1

上面代码在代码块之中，分别用 let 和 var 声明了两个变量，然后在代码块之外调用这两个变量，结果 let 声明的变量报错误，var 声明的变量返回了正确的值。let 声明的变量只在它所在的代码块内有效
for 循环的计数器就很合适使用 let 命令

for (let i = 0; i < 10; i++) {
  //TODOLIST
}
console.log(i)
//语法错误，i 出不来

上面代码中，计数器 i 只在 for 循环体内有效，在循环外引用就会报错
下面的代码如果使用 var 最后输出的就是 10

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

上面代码中变量 i 时 var 声明的，全局范围内都有效，所以全局只有一个变量 i 每一次循环，变量 i 的值都会发生改变，而循环内被赋给数组 a 的函数内部的 console.log(i);里面的 i 指向的就是全局的 i,也就是说所有数组 a 的成员里面的 i，都指向是同一个 i,导致运行时输出的是最后一轮 i 的值，也就是 10
如果使用 let,声明的变量仅仅在块级作用域内有效，最后输出的就是 6

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

上面代码中,变量 i 是 let 声明的，当前 i 只在本循环内有效，所以每一次循环的 i 都是一个新的变量，最后输出的就是 6.因为是新的变量，JS 内部会记住上一轮循环的值，初始化本轮的变量 i，就在上一轮循环的基础上进行计算。
另外 for 循环还有一个特别之处就是设置循环变量的那部分是一个父作用域,而循环体内部是一个单独的作用域

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

上面代码正确运行，输出了 3 次 abc，这表明函数内部的变量 i 与循环 i 不在同一个作用域.函数内部的变量 i 更像是全局的变量 i，而循环 i 则是子循环体

(2)不存在变量提升

var 命令会发生”变量提升”现象，即变量可以在声明之前使用，值就是 undefined,这种现象非常奇怪，一般情况是变量应该在声明语句之后才可以使用
为了纠正这种现象，let 改变了语法行为，他所声明的变量一定要在声明后使用，否则报错
例如 :

//var 情况
console.log(foo) //undefined
var foo = 2
//let情况
console.log(bar) //报错，语法错误
let bar = 2

上面代码中,变量 foo 使用 var 来声明,会发生变量提升，即脚本开始运行时，变量 foo 已经存在了，但是没有值，所以会输出 undefined,变量 bar 用 let 命令声明,不会发生变量提升。这表示在声明之前变量 var 不存在

(3) 暂时性死区

只要快级作用域内存在 let 命令，他所声明的变量就绑定在这个区域，不在接受外部的影响

var tmp = 123
if (true) {
  tmp = 'abc' //语法错误，因为块级作用域已经定义了let而变量使用不能再let之前使用
  let tmp
}

上面代码中存在全局变量 tmp.但是块级作用域内又声明了一个局部变量 tmp 导致后者绑定这个块级作用域，所以在 let 变量声明之前，对 tmp 赋值就会报错

es6 明确规定，如果区块中存在 let 和 const 命令，这个区块对这些命令声明的变量，从一开始就形成了封闭作用域，凡是声明之前就是用这些变量，就会报错。

一句话:在代码块内，使用 let 命令声明变量之前，该变量都是不可用的。这在语法上乘坐 TDZ(暂时性死区)

if (true) {
  //TDZ 开始
  tmp = 'abc'
  console.log(tmp) //语法错误
  let tmp //TDZ结束
  console.log(tmp) //undefined
  tmp = 123
  console.log(tmp) //123
}

在上面代码中，在使用 let 命令声明变量 tmp 之前，都属于 tmp 的”死区”
“暂时性死区” 也意味着 typeof 不再是一个百分百安全的操作

typeof x //语法错误
let x

上面代码中 x 使用了 let 命令来声明，在声明之前，都属于 x 的死区。只要用到该变量就会报错误，因此 typeof 运行的时候就会爆出一个语法错误
而作为比较，如果一个变量根本没有被声明，使用 typeof 反而不会报错

typeof K //undefined

上面代码中 K 是一个不存在的变量名，结果返回的就是 undefined 所以在没有 let 之前 typeof 是百分百安全的，永远不会报错。但是现在不行了。变量一定要在声明之后使用，否则就报错
有些死区很隐蔽，不太容易被发现比如

function bar(x = y, y = 3) {
  return [x, y]
}
bar() //报错

上面代码中使用 bar 函数之所以报错因为参数 X 默认值等于另外一个参数 Y，而此时 Y 还没有被声明，属于死区，如果 y 的默认值是 x,这样就不会报错了。因为此时 x 已经声明了.

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

另外下面的代码也会报错

var x = x
let x = x //语法错误

上面代码也会报错误，因为使用 let 声明变量时候，只要变量在没有声明之前使用，就会报错。上面这行就属于这个情况。在变量 x 的声明语句还没有执行完成前，就去取 X 的值，导致报错 x 未定义。

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

(4)不允许重复声明

let 不允许在相同的作用域内，重复声明同一个变量。

//报错
function abc() {
  let a = 10
  var a = 1
}
//报错
function abc2() {
  let a = 10
  let a = 1
}

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

function abc(arg) {
  let arg //报错
}
function abc2(arg) {
  {
    let arg
  }
}

(三) 块级作用域

(1)为什么需要块级作用域

ES5 只有全局作用域和块级作用域，没有块级作用域。这带来很多不合理的场景

var tmp = new Date()
function f() {
  console.log(tmp)
  if (false) {
    var tmp = 'Hello world'
  }
}
f() //undefined

上面的代码是:if 代码块的外部使用外层的 tmp 变量，内部使用内层的 tmp 变量，但是函数 f 执行后，输出结果为 undefined 原因在于变量提升。导致内存的 tmp 变量覆盖了外层的 tmp 变量

第二种场景 :用来计数的循环变量泄露为全局变量

var s = 'hello'
for (var i = 0; i < s.length; i++) {
  console.log(i)
}
console.log(i)

(2) ES6 的块级作用域

let 实际上为 JS 新增了块级作用域

function f() {
  let n = 5
  if (true) {
    let n = 10
  }
  console.log(n)
}
f() //5

上面的函数有两个代码块，都声明了变量 n,运行后输出 5，这表示外层代码块不受内层代码块的影响，如果两次都用的是 var 定义 n，最后输出的值是 10

ES6 允许块级作用域的任意嵌套

{
  {
    {
      {
        let a = 'name'
      }
    }
  }
}

上面代码使用了一个 5 层的块级作用域，外层作用域无法读取内层作用域的变量

{
  {
    {
      {
        let name = 'hahaha'
      }
      console.log(name) //报错误
    }
  }
}

内层作用域可以定义外层作用域的同名变量

{
  {
    {
      let name = 'Hello world'
      {
        let name2 = 'Hello world'
      }
    }
  }
}

块级作用域的出现，实际上使得广泛应用的立即执行函数表达式，不必再要了。比如闭包

;(function () {
  //TDOLIST
})()

(3) 块级作用域与函数声明

ES5 规定函数只能在顶层作用域和函数作用域里面声明，不能再块级作用域中声明

//情况一
if (true) {
  function f() {}
}
//情况二
try {
  function f() {}
} catch (e) {
  //....
}

上面的两种函数声明，根据 ES5 写法都是非法的。
但是浏览器没有遵守这个决定，为了兼容以前的旧代码，还是支持在块级作用域之中声明函数的。因此两种情况都能运行，不会报错.

ES6 引入了块级作用域，规定块级作用域中，函数声明语句的行为类似 let,在块级作用域之外不可引用

function f() {
  console.log('Iam outside!!')
}
;(function () {
  if (false) {
    function f() {
      console.log('Iam inside')
    }
  }
  f()
})()

上面代码在 ES5 中运行，会得到 Iam inside 因为在 if 内声明的函数 f 会被提升到函数头部。实际代码如下:

function f() {
  console.log('Iam OutSide')
}
;(function () {
  function f() {
    console.log('Iam inSide')
  }
  if (false) {
  }
  f()
})()

ES6 就不一样了，运行后会报错误

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

在 ES6 浏览器会这样，但是其他浏览器还是会按照 let 走,所以尽量不要再块级作用域

(三)const 命令

基本用法:
const 声明一个只读的常量，一旦声明常量的值就不能改变

const PI = 3.1415
PI = 3 //语法错误

const 声明的变量不得改变值。这意味着 const 一旦声明变量，就必须立马使用它，立即初始化。不能留到以后赋值。

const foo;  //语法错误

上面代码表示对于 const 来说只声明不赋值，就会报错。const 作用域和 let 命令相同，只是在声明所在的块级作用域有效。

if (true) {
  const max = 5
}
max //语法错误

const 命令声明的常量也不是提升，同样存在暂时性死区。只能在声明的位置后面使用

if (true) {
  console.log(max)
  const max = 5 //报语法错误
}

本质 const 实际上保证的不是变量的值不得改动，而是变量指向的那个内存地址不得改动。对于值传递的，值就保存在变量指向那个内存地址，因此等同于常量。对于地址传递的主要是对象和数组，变量指向的内存地址保存的仅仅是一个指针.const 保证指针是固定的。

const foo = {}
//为foo添加一个属性。可以成功
foo.prop = 123
foo.prop //123
//将foo指向另一个对象，就会报错
foo = {} //语法错误

另外一个例子:

const a = []
a.push('hello') //可执行
a.length = 0 //可执行
a = ['Dave'] //报错

上面代码中，常量 a 是一个数组，这个数组本身是可写的，但是如果将另一个数组赋值给 a 就会报错
如果真想冻结应该是用 object.freeze 方法

const foo = object.freeze({})
foo.prop = 123 //报错

雾烟云

https://jsopy.gitee.io/2020/03/11/es62/

本博客所有文章除特別声明外，均采用 CC BY 4.0 许可协议。转载请注明来源雾烟云 !

ES6 Javascript

ES6(三) 数组

本文主要是记录ES6的学习

2020-03-12 ES6

ES6 Javascript

ES6(一) 搭建环境

本文主要是记录ES6的学习

2020-03-10 ES6

ES6 Javascript