ECMAScript 6 笔记(一)

一、ECMAScript 6简介

       1996年11月,JavaScript的创造者Netscape公司,决定将JavaScript提交给国际标准化组织ECMA,希望这种语言能够成为国际标准。次年,ECMA发布262号标准文件(ECMA-262)的第一版,规定了浏览器脚本语言的标准,并将这种语言称为ECMAScript,这个版本就是1.0版。

该标准从一开始就是针对JavaScript语言制定的,但是之所以不叫JavaScript,有两个原因。一是商标,Java是Sun公司的商标,根据授权协议,只有Netscape公司可以合法地使用JavaScript这个名字,且JavaScript本身也已经被Netscape公司注册为商标。二是想体现这门语言的制定者是ECMA,不是Netscape,这样有利于保证这门语言的开放性和中立性。

ECMAScript和JavaScript的关系是,前者是后者的规格,后者是前者的一种实现(另外的ECMAScript方言还有Jscript和ActionScript)。日常场合,这两个词是可以互换的。

二、let与作用域

  1. let

  ES6新增了let命令,用来声明变量。它的用法类似于var,但是所声明的变量,只在let命令所在的代码块内有效。

{
  let a = 10;
  var b = 1;
}

a // ReferenceError: a is not defined.
b // 1

适用场景:for循环

不存在变量提升

let不像var那样会发生“变量提升”现象。所以,变量一定要在声明后使用,否则报错。

// var 的情况
console.log(foo); // 输出undefined
var foo = 2;

// let 的情况
console.log(bar); // 报错ReferenceError
let bar = 2;

  变量foovar命令声明,会发生变量提升,即脚本开始运行时,变量foo已经存在了,但是没有值,所以会输出undefined

  变量barlet命令声明,不会发生变量提升。这表示在声明它之前,变量bar是不存在的,这时如果用到它,就会抛出一个错误。

暂时性死区

  只要块级作用域内存在let命令,它所声明的变量就“绑定”(binding)这个区域,不再受外部的影响。

var tmp = 123;

if (true) {
  tmp = 'abc'; // ReferenceError
  let tmp;
}

  存在全局变量tmp,但是块级作用域内let又声明了一个局部变量tmp,导致后者绑定这个块级作用域,所以在let声明变量前,对tmp赋值会报错。

  如果区块中存在letconst命令,这个区块对这些命令声明的变量,从一开始就形成了封闭作用域。凡是在声明之前就使用这些变量,就会报错。

  如果一个变量声明前使用会报错

typeof x; // ReferenceError
let x;

  如果根本没被声明,为undefined,反而不会报错

typeof undeclared_variable // "undefined"

  这样的设计是为了让大家养成良好的编程习惯,变量一定要在声明之后使用,否则就报错。

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

不允许重复声明

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

  2. 块级作用域

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

  ES6允许块级作用域的任意嵌套,内层作用域可以定义外层作用域的同名变量。

  块级作用域的出现,实际上使得获得广泛应用的立即执行函数表达式(IIFE)不再必要了。

// IIFE 写法
(function () {
  var tmp = ...;
  ...
}());

// 块级作用域写法
{
  let tmp = ...;
  ...
}

块级作用域与函数声明

ES5规定,函数只能在顶层作用域和函数作用域之中声明,不能在块级作用域声明。

// ES5严格模式
'use strict';
if (true) {
  function f() {}
}
// 报错

  ES6 引入了块级作用域,明确允许在块级作用域之中声明函数。块级作用域之中,函数声明语句的行为类似于let,在块级作用域之外不可引用。

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

上述代码结果:

  ES5:I am outside!

  ES6: I am inside!

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

  注意,上面三条规则只对ES6的浏览器实现有效,其他环境的实现不用遵守,还是将块级作用域的函数声明当作let处理。

  考虑到环境导致的行为差异太大,应该避免在块级作用域内声明函数。如果确实需要,也应该写成函数表达式,而不是函数声明语句。

// 函数声明语句
{
  let a = 'secret';
  function f() {
    return a;
  }
}

// 函数表达式
{
  let a = 'secret';
  let f = function () {
    return a;
  };
}

  ES6的块级作用域允许声明函数的规则,只在使用大括号的情况下成立,如果没有使用大括号,就会报错。

do表达式

{
  let t = f();
  t = t * t + 1;
}

  上面代码中,块级作用域将两个语句封装在一起。但是,在块级作用域以外,没有办法得到t的值,因为块级作用域不返回值,除非t是全局变量。

  在块级作用域之前加上do,使它变为do表达式。

let x = do {
  let t = f();
  t * t + 1;
};

  上面代码中,变量x会得到整个块级作用域的返回值。

  3. const命令

const声明一个只读的常量。一旦声明,常量的值就不能改变。

  对于const来说,只声明不赋值,就会报错。

  const的作用域与let命令相同:只在声明所在的块级作用域内有效。

if (true) {
  const MAX = 5;
}

MAX // Uncaught ReferenceError: MAX is not defined
var message = "Hello!";
let age = 25;

// 以下两行都会报错
const message = "Goodbye!";
const age = 30;

   对于复合类型的变量,变量名不指向数据,而是指向数据所在的地址。const命令只是保证变量名指向的地址不变

4. 顶层对象的属性

顶层对象,在浏览器环境指的是window对象,在Node指的是global对象。

  ES5之中,顶层对象的属性与全局变量是等价的。

window.a = 1;
a // 1

a = 2;
window.a // 2

   上面代码中,顶层对象的属性赋值与全局变量的赋值,是同一件事。

  ES6:

  一方面规定,为了保持兼容性,var命令和function命令声明的全局变量,依旧是顶层对象的属性;

  另一方面规定,let命令、const命令、class命令声明的全局变量,不属于顶层对象的属性。

  5. global对象

二、 变量的解构赋值

   ES6允许按照一定模式,从数组和对象中提取值,对变量进行赋值,这被称为解构(Destructuring)。

  1. 数组的解构赋值

var a = 1;
var b = 2;
var c = 3;

//ES6允许写成下面这样。

var [a, b, c] = [1, 2, 3];

  如果解构不成功,变量的值就等于undefined

var [foo] = [];
var [bar, foo] = [1];  

  以上两种情况都属于解构不成功,foo的值都会等于undefined

  另一种情况是不完全解构,即等号左边的模式,只匹配一部分的等号右边的数组。这种情况下,解构依然可以成功。

let [x, y] = [1, 2, 3];
x // 1
y // 2

let [a, [b], d] = [1, [2, 3], 4];
a // 1
b // 2
d // 4

  如果等号的右边不是数组(或者严格地说,不是可遍历的结构,参见《Iterator》一章),那么将会报错。

默认值

解构赋值允许指定默认值

var [foo = true] = [];
foo // true

[x, y = 'b'] = ['a']; // x='a', y='b'
[x, y = 'b'] = ['a', undefined]; // x='a', y='b'

注意,ES6内部使用严格相等运算符(===),判断一个位置是否有值。所以,如果一个数组成员不严格等于undefined,默认值是不会生效的。

var [x = 1] = [undefined];
x // 1

var [x = 1] = [null];
x // null

  上面代码中,如果一个数组成员是null,默认值就不会生效,因为null不严格等于undefined

  如果默认值是一个表达式,那么这个表达式是惰性求值的,即只有在用到的时候,才会求值。

function f() {
  console.log('aaa');
}

let [x = f()] = [1];

  上面代码中,因为x能取到值,所以函数f根本不会执行。上面的代码其实等价于下面的代码。

let x;
if ([1][0] === undefined) {
  x = f();
} else {
  x = [1][0];
}

  2. 对象的解构赋值

var { foo, bar } = { foo: "aaa", bar: "bbb" };
foo // "aaa"
bar // "bbb"

  对象的解构与数组有一个重要的不同。数组的元素是按次序排列的,变量的取值由它的位置决定;

  而对象的属性没有次序,变量必须与属性同名,才能取到正确的值。

对象的解构赋值的内部机制,是先找到同名属性,然后再赋给对应的变量。真正被赋值的是后者,而不是前者。

对于letconst来说,变量不能重新声明,所以一旦赋值的变量以前声明过,就会报错。

let foo;
({foo} = {foo: 1}); // 成功

let baz;
({bar: baz} = {bar: 1}); // 成功

  上面代码中,let命令下面一行的圆括号是必须的,否则会报错。因为解析器会将起首的大括号,理解成一个代码块,而不是赋值语句。

var node = {
  loc: {
    start: {
      line: 1,
      column: 5
    }
  }
};

var { loc: { start: { line }} } = node;
line // 1
loc  // error: loc is undefined
start // error: start is undefined

  上面代码中,只有line是变量,locstart都是模式,不会被赋值。

  对象的解构也可以指定默认值。如果解构失败,变量的值等于undefined。如果解构模式是嵌套的对象,而且子对象所在的父属性不存在,那么将会报错。

  由于数组本质是特殊的对象,因此可以对数组进行对象属性的解构。

var arr = [1, 2, 3];
var {0 : first, [arr.length - 1] : last} = arr;
first // 1
last // 3

  3. 字符串的解构赋

  字符串被转换成了一个类似数组的对象。

const [a, b, c, d, e] = 'hello';
a // "h"
b // "e"
c // "l"
d // "l"
e // "o"

  类似数组的对象都有一个length属性,因此还可以对这个属性解构赋值。

let {length : len} = 'hello';
len // 5

  4. 数值和布尔值的解构赋值

  解构赋值时,如果等号右边是数值和布尔值,则会先转为对象。

let {toString: s} = 123;
s === Number.prototype.toString // true

let {toString: s} = true;
s === Boolean.prototype.toString // true

  上面代码中,数值和布尔值的包装对象都有toString属性,因此变量s都能取到值。

  解构赋值的规则是,只要等号右边的值不是对象,就先将其转为对象。由于undefinednull无法转为对象,所以对它们进行解构赋值,都会报错。

  5. 函数参数的解构赋值

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

add([1, 2]); // 3

  函数add的参数表面上是一个数组,但在传入参数的那一刻,数组参数就被解构成变量xy。对于函数内部的代码来说,它们能感受到的参数就是xy

[[1, 2], [3, 4]].map(([a, b]) => a + b);
// [ 3, 7 ]

function move({x, y} = { x: 0, y: 0 }) {
  return [x, y];
}

move({x: 3, y: 8}); // [3, 8]
move({x: 3}); // [3, undefined]
move({}); // [undefined, undefined]
move(); // [0, 0]

  上面代码是为函数move的参数指定默认值,而不是为变量xy指定默认值,所以会得到与前一种写法不同的结果。

undefined就会触发函数参数的默认值。

[1, undefined, 3].map((x = 'yes') => x);
// [ 1, 'yes', 3 ]

只要有可能,就不要在模式中放置圆括号。

  不能使用圆括号的情况

  (1)变量声明语句中,不能带有圆括号

  (2)函数参数中,模式不能带有圆括号。

  (3)赋值语句中,不能将整个模式,或嵌套模式中的一层,放在圆括号之中。

// 全部报错
var [(a)] = [1];
function f([(z)]) { return z; }
({ p: a }) = { p: 42 };
([a]) = [5];

  可以使用圆括号的情况只有一种:赋值语句的非模式部分,可以使用圆括号。

[(b)] = [3]; // 正确
({ p: (d) } = {}); // 正确
[(parseInt.prop)] = [3]; // 正确

  面三行语句都可以正确执行,因为首先它们都是赋值语句,而不是声明语句;其次它们的圆括号都不属于模式的一部分。第一行语句中,模式是取数组的第一个成员,跟圆括号无关;第二行语句中,模式是p,而不是d;第三行语句与第一行语句的性质一致。

  6. 用途

(1)交换变量的值

[x, y] = [y, x];

(2)从函数返回多个值

  函数只能返回一个值,如果要返回多个值,只能将它们放在数组或对象里返回。有了解构赋值,取出这些值就非常方便。

// 返回一个数组

function example() {
  return [1, 2, 3];
}
var [a, b, c] = example();

// 返回一个对象

function example() {
  return {
    foo: 1,
    bar: 2
  };
}
var { foo, bar } = example();

  (3)函数参数的定义

  解构赋值可以方便地将一组参数与变量名对应起来。

// 参数是一组有次序的值
function f([x, y, z]) { ... }
f([1, 2, 3]);

// 参数是一组无次序的值
function f({x, y, z}) { ... }
f({z: 3, y: 2, x: 1});

  (4)提取JSON数据

  解构赋值对提取JSON对象中的数据,尤其有用。

var jsonData = {
  id: 42,
  status: "OK",
  data: [867, 5309]
};

let { id, status, data: number } = jsonData;

console.log(id, status, number);
// 42, "OK", [867, 5309]

  (5)函数参数的默认值

jQuery.ajax = function (url, {
  async = true,
  beforeSend = function () {},
  cache = true,
  complete = function () {},
  crossDomain = false,
  global = true,
  // ... more config
}) {
  // ... do stuff
};

  (6)遍历Map结构

任何部署了Iterator接口的对象,都可以用for...of循环遍历。

  在ES6中,有三类数据结构原生具备Iterator接口: 数组、某些类似数组的对象、Set和Map结构 ,对象(Object)之所以没有默认部署Iterator接口,是因为对象的哪个属性先遍历,哪个属性后遍历是不确定的,需要开发者手动指定。

  Iterator接口部署在对象的 Symbol.Iterator 属性上, 可以调用这个属性,就得到遍历器对象。

var arr = ['a', 'b', 'c'];
var iterator = arr[Symbol.iterator]();
var a = iterator.next();
console.log(a)   //{value: 'a', done: false}

for–of与for–in

for...in 遍历每一个属性名称,而 for...of遍历每一个属性值。

  在对象没有部署Iterator接口的情况下调用for…of会报错。当一个部署了Iterator接口的对象调用for…of时,实现的步骤是这样的:

  1. 调用对象的Symbol.Iterator的属性获得遍历器生成函数;
  2. 调用遍历器生成函数返回遍历器对象其实for…of就相当于一直调用遍历器对象的next方法,直到返回done为true;

  Map结构原生支持Iterator接口,配合变量的解构赋值,获取键名和键值就非常方便。

var map = new Map();
map.set('first', 'hello');
map.set('second', 'world');

for (let [key, value] of map) {
  console.log(key + " is " + value);
}
// first is hello
// second is world

  如果只想获取键名,或者只想获取键值,可以写成下面这样。

// 获取键名
for (let [key] of map) {
  // ...
}

// 获取键值
for (let [,value] of map) {
  // ...
}

  (7)输入模块的指定方法

  加载模块时,往往需要指定输入那些方法。解构赋值使得输入语句非常清晰。

const { SourceMapConsumer, SourceNode } = require("source-map");

电子书来源:阮一峰

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏二进制文集

30分钟玩转「正则表达式」

推荐阅读:Jeffrey Friedl 《精通正则表达式(第3版)》,本文是该书的读书笔记。

13520
来自专栏玄魂工作室

如何学python 第十二课 逻辑运算符-成员运算符

第十二课 逻辑运算符-成员运算符 上一节我们介绍了元组和字典。这节课我们讨论点别的,逻辑运算符和成员运算符(有些人也把这个翻译成身份运算符)。他们和布尔类型紧密...

35050
来自专栏于晓飞的专栏

Java 泛型进阶

在 List<String> 中添加 Integer 将不会通过编译,但是List<Sring>与List<Integer>在运行时的确是同一种类型。

24630
来自专栏博客园

IL指令详细表

10220
来自专栏阿炬.NET

Reflector、reflexil、De4Dot、IL指令速查表

35150
来自专栏青玉伏案

窥探Swift之字符串(String)

  之前总结过Objective-C中的字符串《Objective-C精选字符串处理方法》,学习一门新语言怎么能少的了字符串呢。Swift中的String和Ob...

24760
来自专栏飞雪无情的博客

Go语言实战笔记(七)| Go 类型

Go 语言是一种静态类型的编程语言,所以在编译器进行编译的时候,就要知道每个值的类型,这样编译器就知道要为这个值分配多少内存,并且知道这段分配的内存表示什么。

9530
来自专栏前端架构与工程

【译】《Understanding ECMAScript6》- 第二章-函数

函数在任何一门编程语言中都是很重要的一个环节。JavaScript至今已有多年的历史,但是它的函数仍然停留在很初级的阶段。函数问题的大量堆积,以及某些函数非常微...

23170
来自专栏lulianqi

IL指令详细

13530
来自专栏Flutter入门到实战

老司机用一篇博客带你快速熟悉Dart语法

版权声明:本文为博主原创文章,未经博主允许不得转载。https://www.jianshu.com/p/3d927a7bf020

51420

扫码关注云+社区

领取腾讯云代金券