ES6总结

Lostsleep

已于 2024-08-16 14:43:58 修改

阅读量562

点赞数 6

文章标签： es6 前端 javascript

于 2024-08-16 14:43:16 首次发布

本文链接：https://blog.csdn.net/weixin_42727450/article/details/141259095

版权

let和const

let和const都用于声明局部变量，

let声明变量，同时声明多个相同变量会报错

const声明常量。声明简单类型，赋值会报错；声明复杂类型，赋值不会报错（没有修改引用）。

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

字符串扩展

模板字符串： `${ string }`

模板标签：模板字符串的功能，不仅仅是上面这些。它可以紧跟在一个函数名后面，该函数将被调用来处理这个模板字符串。这被称为“标签模板”功能。

如果模板字符里面有变量，就不是简单的调用了，而是会将模板字符串先处理成多个参数，再调用函数。

新增方法：

String.fromCodePoint()：从 Unicode 码点返回对应字符

String.codePointAt()：返回的是码点的十进制值，如果想要十六进制的值，可以使用toString()方法转换一下：codePointAt(字符).toString(16)

String.raw():该方法返回一个斜杠都被转义（即斜杠前面再加一个斜杠）的字符串，往往用于模板字符串的处理方法。

includes(string, n)：返回布尔值，表示是否找到了参数字符串。从第n个位置直到字符串结束

startsWith(string, n)：返回布尔值，表示参数字符串是否在原字符串的头部。从第n个位置直到字符串结束

endsWith(string, n)：返回布尔值，表示参数字符串是否在原字符串的尾部。前n个字符

repeat(n): 返回一个新字符串，表示将原字符串重复n次。参数如果是小数，会被取整。

padStart()和padEnd()：一共接受两个参数，第一个参数是字符串补全生效的最大长度，第二个参数是用来补全的字符串。如果用来补全的字符串与原字符串，两者的长度之和超过了最大长度，则会截去超出位数的补全字符串。如果省略第二个参数，默认使用空格补全长度。

at(): 接受一个整数作为参数，返回参数指定位置的字符，支持负索引（即倒数的位置）。如果参数位置超出了字符串范围，at()返回undefined。

正则扩展

y修饰符：“粘连”（sticky）修饰符。y修饰符的作用与g修饰符类似，也是全局匹配，后一次匹配都从上一次匹配成功的下一个位置开始。不同之处在于，g修饰符只要剩余位置中存在匹配就可，而y修饰符确保匹配必须从剩余的第一个位置开始，这也就是“粘连”的涵义。

u修饰符：含义为“Unicode 模式”，用来正确处理大于\uFFFF的 Unicode 字符

s修饰符：s修饰符，使得.可以匹配任意单个字符。这被称为dotAll模式

sticky属性：表示是否设置了y修饰符。

flags属性：返回正则表达式的修饰符

source属性：返回正则表达式的正文（ES5）

/(?<=y)x/(后行断言)：x只有在y后面才匹配

/(?<!y)x/(后行否定断言)：x只有不在y后面才匹配

ES5 先行断言

/x(?=y)/（先行断言）：x只有在y前面才匹配

/x(?!y)/（先行否定断言）：x只有不在y前面才匹配

具名组匹配，允许为每一个组匹配指定一个名字，既便于阅读代码，又便于引用

数值扩展

ES6 提供了二进制和八进制数值的新的写法，分别用前缀0b（或0B）和0o（或0O）表示。

数值分隔符

ES2021，允许 JavaScript 的数值使用下划线（_）作为分隔符

不能放在数值的最前面（leading）或最后面（trailing）。

不能两个或两个以上的分隔符连在一起。

小数点的前后不能有分隔符。

科学计数法里面，表示指数的e或E前后不能有分隔符。

Number()，parseInt()，parseFloat()不支持数值分隔符

Number.isFinite()：用来检查一个数值是否为有限的（finite），即不是Infinity。对于非数值一律返回false

Number.isNaN()：用来检查一个值是否为NaN。只有对于NaN才返回true，非NaN一律返回false。

Number.isInteger()：用来判断一个数值是否为整数。

Number.isSafeInteger()：则是用来判断一个整数是否落在这个范围之内。-2^53~2^53

Math扩展：

Math.trunc()：方法用于去除一个数的小数部分，返回整数部分。对于非数值，Math.trunc内部使用Number方法将其先转为数值。对于空值和无法截取整数的值，返回NaN。

Math.sign(): 方法用来判断一个数到底是正数、负数、还是零。对于非数值，会先将其转换为数值。

参数为正数，返回+1；

参数为负数，返回-1；

参数为 0，返回0；

参数为-0，返回-0;

其他值，返回NaN。

函数扩展

ES6 允许为函数的参数设置默认值，即直接写在参数定义的后面。参数变量是默认声明的，在函数体中，不能用let或const再次声明，否则会报错。

length属性：将返回没有指定默认值的参数个数。

name属性：返回该函数的函数名。

ES6 引入 rest 参数（形式为...变量名），用于获取函数的多余参数，这样就不需要使用

arguments对象了。rest 参数搭配的变量是一个数组，该变量将多余的参数放入数组中。

箭头函数

箭头函数有几个使用注意点。

（1）箭头函数没有自己的this对象（详见下文）。

（2）不可以当作构造函数，也就是说，不可以对箭头函数使用new命令，否则会抛出一个错误。

（3）不可以使用arguments对象，该对象在函数体内不存在。如果要用，可以用 rest 参数代替。

（4）不可以使用yield命令，因此箭头函数不能用作 Generator 函数。

上面四点中，最重要的是第一点。对于普通函数来说，内部的this指向函数运行时所在的对象，但是这一点对箭头函数不成立。它没有自己的this对象，内部的this就是定义时上层作用域中的this。也就是说，箭头函数内部的this指向是固定的，相比之下，普通函数的this指向是可变的。

不适用箭头函数场合：

1.第一个场合是定义对象的方法，且该方法内部包括this。

2.第二个场合是需要动态this的时候，也不应使用箭头函数。(例如绑定事件)

数组扩展

扩展运算符（spread）是三个点（...）。它好比 rest 参数的逆运算，将一个数组转为用逗号分隔的参数序列。扩展运算符还可以将字符串转为真正的数组。

Array.from()：用于将两类对象转为真正的数组：类似数组的对象（array-like object）和可遍历（iterable）的对象。

Array.of()：用于将一组值，转换为数组。

copyWithin()：在当前数组内部，将指定位置的成员复制到其他位置（会覆盖原有成员），然后返回当前数组。也就是说，使用这个方法，会修改当前数组。

target（必需）：从该位置开始替换数据。如果为负值，表示倒数。

start（可选）：从该位置开始读取数据，默认为 0。如果为负值，表示从末尾开始计算。

end（可选）：到该位置前停止读取数据，默认等于数组长度。如果为负值，表示从末尾开始计算。

find()：用于找出第一个符合条件的数组成员。它的参数是一个回调函数，所有数组成员依次执行该回调函数，直到找出第一个返回值为true的成员，然后返回该成员。如果没有符合条件的成员，则返回undefined。

findIndex()： findIndex()方法的用法与find()方法非常类似，返回第一个符合条件的数组成员的位置，如果所有成员都不符合条件，则返回-1。

findLast()和findLastIndex()：从数组的最后一个成员开始，依次向前检查，其他都保持不变。

fill（）：使用给定值，填充一个数组。还可以接受第二个和第三个参数，用于指定填充的起始位置和结束位置。

keys()是对键名的遍历、values()是对键值的遍历，entries()是对键值对的遍历。

includes（）方法返回一个布尔值，表示某个数组是否包含给定的值，与字符串的includes方法类似。该方法的第二个参数表示搜索的起始位置，默认为0。

flat()用于将嵌套的数组“拉平”，变成一维的数组。该方法返回一个新数组，对原数据没有影响。

参数表示拉平的层数，默认值是1。如果不管有多少层嵌套，都要转成一维数组，可以用Infinity关键字作为参数。

flatMap()方法对原数组的每个成员执行一个函数（相当于执行Array.prototype.map()），然后对返回值组成的数组执行flat()方法（只能展开一层数组）。该方法返回一个新数组，不改变原数组。

at()方法，接受一个整数作为参数，返回对应位置的成员，并支持负索引。这个方法不仅可用于数组，也可用于字符串。

对象扩展

属性简洁表示

属性名表达式

super关键字指向当前对象的原型对象。只能用在对象的方法之中，用在其他地方都会报错。

扩展运算符(...)用于展开对象

Object.is（）它用来比较两个值是否严格相等，与严格比较运算符（===）的行为基本一致。不同之处只有两个：一是+0不等于-0，二是NaN等于自身。

Object.assign()方法用于对象的合并，将源对象（source）的所有可枚举属性，复制到目标对象（target）。方法的第一个参数是目标对象，后面的参数都是源对象。注意，如果目标对象与源对象有同名属性，或多个源对象有同名属性，则后面的属性会覆盖前面的属性。

__proto__属性（前后各两个下划线），用来读取或设置当前对象的原型对象（prototype）。

Object.setPrototypeOf（）方法的作用与__proto__相同，用来设置一个对象的原型对象（prototype），返回参数对象本身。

Object.getPrototypeOf（）用于读取一个对象的原型对象。

Object.keys（）方法，返回一个数组，成员是参数对象自身的（不含继承的）所有可遍历（enumerable）属性的键名。

Object.values（）方法返回一个数组，成员是参数对象自身的（不含继承的）所有可遍历（enumerable）属性的键值。

Object.entries()方法返回一个数组，成员是参数对象自身的（不含继承的）所有可遍历（enumerable）属性的键值对数组。

Object.fromEntries()方法是Object.entries()的逆操作，用于将一个键值对数组转为对象。

Object.hasOwn()判断是否为自身的属性，可以接受两个参数，第一个是所要判断的对象，第二个是属性名。

运算符扩展

指数运算符（**）：2**2 === 4 // true

链判断运算符(?.)：直接在链式调用的时候判断，左侧的对象是否为null或undefined。如果是的，就不再往下运算，而是返回undefined。

Null 判断运算符??：有运算符左侧的值为null或undefined时，才会返回右侧的值。这个运算符的一个目的，就是跟链判断运算符?.配合使用，为null或undefined的值设置默认值。

Symbol

Symbol 值通过Symbol()函数生成。是原始数据类型Symbol，表示独一无二的值。这就是说，对象的属性名现在可以有两种类型，一种是原来就有的字符串，另一种就是新增的 Symbol 类型。凡是属性名属于 Symbol 类型，就都是独一无二的，可以保证不会与其他属性名产生冲突。

Symbol.prototype.description属性：直接返回 Symbol 值的描述。

魔术字符串指的是，在代码之中多次出现、与代码形成强耦合的某一个具体的字符串或者数值。风格良好的代码，应该尽量消除魔术字符串，改由含义清晰的变量代替

Symbol.for(key):接受一个字符串作为参数，然后搜索有没有以该参数作为名称的 Symbol 值。如果有，就返回这个 Symbol 值，否则就新建一个以该字符串为名称的 Symbol 值，并将其注册到全局。

Symbol.keyFor(Symbol):返回一个已登记的 Symbol 类型值的key。

Set和Map数据结构

Set数据结构

ES6 提供了新的数据结构 Set。它类似于数组，但是成员的值都是唯一的，没有重复的值。

Set 结构的实例有以下属性。

Set.prototype.constructor：构造函数，默认就是Set函数。

Set.prototype.size：返回Set实例的成员总数。

Set 实例的方法分为两大类：操作方法（用于操作数据）和遍历方法（用于遍历成员）。下面先介绍四个操作方法。

Set.prototype.add(value)：添加某个值，返回 Set 结构本身。

Set.prototype.delete(value)：删除某个值，返回一个布尔值，表示删除是否成功。

Set.prototype.has(value)：返回一个布尔值，表示该值是否为Set的成员。

Set.prototype.clear()：清除所有成员，没有返回值。

Set 结构的实例有四个遍历方法，可以用于遍历成员。由于 Set 结构没有键名，只有键值（或者说键名和键值是同一个值），所以keys方法和values方法的行为完全一致。

Set.prototype.keys()：返回键名的遍历器

Set.prototype.values()：返回键值的遍历器

Set.prototype.entries()：返回键值对的遍历器

Set.prototype.forEach()：使用回调函数遍历每个成员

*扩展运算符（...）内部使用for...of循环, for...of内部是Iterator的next实现

数组的map和filter方法也可以间接用于 Set 了。因此使用 Set 可以很容易地实现并集（Union）、交集（Intersect）和差集（Difference）。

WeakSet 结构与 Set 类似，也是不重复的值的集合。但是，它与 Set 有两个区别。

1.WeakSet 的成员只能是对象，而不能是其他类型的值。

2. WeakSet 中的对象都是弱引用，即垃圾回收机制不考虑 WeakSet 对该对象的引用

Map数据结构

ES6 提供了 Map 数据结构。它类似于对象，也是键值对的集合，但是“键”的范围不限于字符串，各种类型的值（包括对象）都可以当作键。

1.简单数据类型作为键，只要两个值严格相等，Map 将其视为一个键，比如0和-0就是一个键，布尔值true和字符串true则是两个不同的键。另外，undefined和null也是两个不同的键。虽然NaN不严格相等于自身，但 Map 将其视为同一个键。

2.复杂数据类型作为键，Map 的键实际上是跟内存地址绑定的，只要内存地址不一样，就视为两个键。

size：属性返回 Map 结构的成员总数。

Map.prototype.set(key, value)：set方法设置键名key对应的键值为value，然后返回整个 Map 结构。如果key已经有值，则键值会被更新，否则就新生成该键。set方法返回的是当前的Map对象，因此可以采用链式写法。

Map.prototype.get(key)：get方法读取key对应的键值，如果找不到key，返回undefined。

Map.prototype.has(key)：has方法返回一个布尔值，表示某个键是否在当前 Map 对象之中。

Map.prototype.delete(key)：delete方法删除某个键，返回true。如果删除失败，返回false。

Map.prototype.clear()：clear方法清除所有成员，没有返回值。

Map 结构原生提供三个遍历器生成函数和一个遍历方法。

Map.prototype.keys()：返回键名的遍历器。

Map.prototype.values()：返回键值的遍历器。

Map.prototype.entries()：返回所有成员的遍历器。

Map.prototype.forEach()：遍历 Map 的所有成员。

WeakMap结构与Map结构类似，也是用于生成键值对的集合。WeakMap与Map的区别有两点。

1.WeakMap只接受对象作为键名（null除外），不接受其他类型的值作为键名。

2.其次，WeakMap的键名所指向的对象，不计入垃圾回收机制。

proxy代理

Proxy 用于修改某些操作的默认行为，等同于在语言层面做出修改，所以属于一种“元编程”（meta programming），即对编程语言进行编程。Proxy 可以理解成，在目标对象之前架设一层“拦截”，外界对该对象的访问，都必须先通过这层拦截，因此提供了一种机制，可以对外界的访问进行过滤和改写。Proxy 这个词的原意是代理，用在这里表示由它来“代理”某些操作，可以译为“代理器”。

下面是 Proxy 支持的拦截操作一览，一共 13 种。

get(target, propKey, receiver)：拦截对象属性的读取，比如proxy.foo和proxy['foo']。

set(target, propKey, value, receiver)：拦截对象属性的设置，比如proxy.foo = v或proxy['foo'] = v，返回一个布尔值。

has(target, propKey)：拦截propKey in proxy的操作，返回一个布尔值。

deleteProperty(target, propKey)：拦截delete proxy[propKey]的操作，返回一个布尔值。

ownKeys(target)：拦截Object.getOwnPropertyNames(proxy)、Object.getOwnPropertySymbols(proxy)、Object.keys(proxy)、for...in循环，返回一个数组。该方法返回目标对象所有自身的属性的属性名，而Object.keys()的返回结果仅包括目标对象自身的可遍历属性。

getOwnPropertyDescriptor(target, propKey)：拦截Object.getOwnPropertyDescriptor(proxy, propKey)，返回属性的描述对象。

defineProperty(target, propKey, propDesc)：拦截Object.defineProperty(proxy, propKey, propDesc）、Object.defineProperties(proxy, propDescs)，返回一个布尔值。

preventExtensions(target)：拦截Object.preventExtensions(proxy)，返回一个布尔值。

getPrototypeOf(target)：拦截Object.getPrototypeOf(proxy)，返回一个对象。

isExtensible(target)：拦截Object.isExtensible(proxy)，返回一个布尔值。

setPrototypeOf(target, proto)：拦截Object.setPrototypeOf(proxy, proto)，返回一个布尔值。如果目标对象是函数，那么还有两种额外操作可以拦截。

apply(target, object, args)：拦截 Proxy 实例作为函数调用的操作，比如proxy(...args)、proxy.call(object, ...args)、proxy.apply(...)。

construct(target, args)：拦截 Proxy 实例作为构造函数调用的操作，比如new proxy(...args)。

reflect反射

Reflect对象与Proxy对象一样，也是 ES6 为了操作对象而提供的新 API。Reflect对象的设计目的有这样几个。

（1）将Object对象的一些明显属于语言内部的方法（比如Object.defineProperty），放到Reflect对象上。现阶段，某些方法同时在Object和Reflect对象上部署，未来的新方法将只部署在Reflect对象上。也就是说，从Reflect对象上可以拿到语言内部的方法。

（2）修改某些Object方法的返回结果，让其变得更合理。比如，Object.defineProperty(obj, name, desc)在无法定义属性时，会抛出一个错误，而Reflect.defineProperty(obj, name, desc)则会返回false。

（3）让Object操作都变成函数行为。某些Object操作是命令式，比如name in obj和delete obj[name]，而Reflect.has(obj, name)和Reflect.deleteProperty(obj, name)让它们变成了函数行为。

（4）Reflect对象的方法与Proxy对象的方法一一对应，只要是Proxy对象的方法，就能在Reflect对象上找到对应的方法。这就让Proxy对象可以方便地调用对应的Reflect方法，完成默认行为，作为修改行为的基础。也就是说，不管Proxy怎么修改默认行为，你总可以在Reflect上获取默认行为。

Reflect对象一共有 13 个静态方法。

Reflect.apply(target, thisArg, args)

Reflect.construct(target, args)

Reflect.get(target, name, receiver)

Reflect.set(target, name, value, receiver)

Reflect.defineProperty(target, name, desc)

Reflect.deleteProperty(target, name)

Reflect.has(target, name)

Reflect.ownKeys(target)

Reflect.isExtensible(target)

Reflect.preventExtensions(target)

Reflect.getOwnPropertyDescriptor(target, name)

Reflect.getPrototypeOf(target)

Reflect.setPrototypeOf(target, prototype)

上面这些方法的作用，大部分与Object对象的同名方法的作用都是相同的，而且它与Proxy对象的方法是一一对应的。

promise

Promise对象有以下两个特点。

（1）对象的状态不受外界影响。Promise对象代表一个异步操作，有三种状态：pending（进行中）、fulfilled（已成功）和rejected（已失败）。只有异步操作的结果，可以决定当前是哪一种状态，任何其他操作都无法改变这个状态。这也是Promise这个名字的由来，它的英语意思就是“承诺”，表示其他手段无法改变。

（2）一旦状态改变，就不会再变，任何时候都可以得到这个结果。Promise对象的状态改变，只有两种可能：从pending变为fulfilled和从pending变为rejected。只要这两种情况发生，状态就凝固了，不会再变了，会一直保持这个结果，这时就称为 resolved（已定型）。如果改变已经发生了，你再对Promise对象添加回调函数，也会立即得到这个结果。这与事件（Event）完全不同，事件的特点是，如果你错过了它，再去监听，是得不到结果的。

Promise.prototype.then: Promise 实例具有then方法，也就是说，then方法是定义在原型对象Promise.prototype上的。它的作用是为 Promise 实例添加状态改变时的回调函数。前面说过，then方法的第一个参数是resolved状态的回调函数，第二个参数是rejected状态的回调函数，它们都是可选的。then方法返回的是一个新的Promise实例（注意，不是原来那个Promise实例）。因此可以采用链式写法，即then方法后面再调用另一个then方法。

Promise.prototype.catch():用于指定发生错误时的回调函数

Promise.prototype.finally():不管 Promise 对象最后状态如何，都会执行的操作。在执行完then或catch指定的回调函数以后，都会执行finally方法指定的回调函数。

Promise.all():方法用于将多个 Promise 实例，包装成一个新的 Promise 实例。

p的状态由p1、p2、p3决定，分成两种情况。

（1）只有p1、p2、p3的状态都变成fulfilled，p的状态才会变成fulfilled，此时p1、p2、p3的返回值组成一个数组，传递给p的回调函数。

（2）只要p1、p2、p3之中有一个被rejected，p的状态就变成rejected，此时第一个被reject的实例的返回值，会传递给p的回调函数。

Promise.race(): 只要p1、p2、p3之中有一个实例率先改变状态，p的状态就跟着改变。那个率先改变的 Promise 实例的返回值，就传递给p的回调函数。

Promise.allSettled(): 一组异步操作是否都结束了（不管成功或失败）,该方法返回的新的 Promise 实例，一旦发生状态变更，状态总是fulfilled，不会变成rejected。状态变成fulfilled后，它的回调函数会接收到一个数组作为参数，该数组的每个成员对应前面数组的每个 Promise 对象。

Promise.any(): 只要参数实例有一个变成fulfilled状态，包装实例就会变成fulfilled状态；如果所有参数实例都变成rejected状态，包装实例就会变成rejected状态。

Promise.resolve(): 将现有对象转为 Promise 对象,状态为resolved

Promise.reject(reason):方法也会返回一个新的 Promise 实例，该实例的状态为rejected。

Iterator和for....of

原生具备 Iterator 接口的数据结构如下。

Array

Map

Set

String

TypedArray

函数的 arguments 对象

NodeList 对象

下面的例子是数组的Symbol.iterator属性。

Generator函数

Generator函数调用后并不立即执行，必须调用遍历器对象的next方法，使得指针移向下一个状态。

遍历器对象的next方法的运行逻辑如下。

（1）遇到yield表达式，就暂停执行后面的操作，并将紧跟在yield后面的那个表达式的值，作为返回的对象的value属性值。

（2）下一次调用next方法时，再继续往下执行，直到遇到下一个yield表达式。

（3）如果没有再遇到新的yield表达式，就一直运行到函数结束，直到return语句为止，并将return语句后面的表达式的值，作为返回的对象的value属性值。

（4）如果该函数没有return语句，则返回的对象的value属性值为undefined。

for...of循环可以自动遍历 Generator 函数运行时生成的Iterator对象，且此时不再需要调用next方法。

Generator.prototype.throw:可以在函数体外抛出错误，然后在 Generator 函数体内捕获。

Generator.prototype.return:可以返回给定的值，并且终结遍历 Generator 函数。

async..await函数

async函数返回一个 Promise 对象，可以使用then方法添加回调函数。当函数执行的时候，一旦遇到await就会先返回，等到异步操作完成，再接着执行函数体内后面的语句。

Class语法

constructor()方法是类的默认方法，通过new命令生成对象实例时，自动调用该方法。一个类必须有constructor()方法，如果没有显式定义，一个空的constructor()方法会被默认添加。

Class类的prototype === 实例的__proto__

ES2022正式为class添加了私有属性，方法是在属性名之前使用#表示。只能在类的内部使用（this.#count）。如果在类的外部使用，就会报错。

对于JavaScript中静态函数的描述：

类相当于实例的模型，所有在类中定义的函数都会被实例所继承，如果在该函数上加上一个static关键字，就表示该函数不会被实例继承，而是通过类来调用，这就称为静态函数。

上面代码确保构造函数只能通过new命令调用。Class 内部调用new.target，返回当前 Class。

Class的继承

Class 可以通过extends关键字实现继承，让子类继承父类的属性和方法。extends 的写法比 ES5 的原型链继承，要清晰和方便很多。

ES6 规定，子类必须在constructor()方法中调用super()，否则就会报错。这是因为子类自己的this对象，必须先通过父类的构造函数完成塑造，得到与父类同样的实例属性和方法，然后再对其进行加工，添加子类自己的实例属性和方法。如果不调用super()方法，子类就得不到自己的this对象。子类构造函数调用super()时，会执行一次父类构造函数。

父类所有的属性和方法，都会被子类继承，除了私有的属性和方法。

父类的静态属性和静态方法，也会被子类继承，是浅拷贝，修改不会影响到父类。

Object.getPrototypeOf()方法可以用来从子类上获取父类

super

super这个关键字，既可以当作函数使用，也可以当作对象使用。在这两种情况下，它的用法完全不同。

第一种情况，super作为函数调用时，代表父类的构造函数。ES6 要求，子类的构造函数必须执行一次super()函数。

第二种情况，super作为对象时，在普通方法中，指向父类的原型对象，定义在父类实例上的方法或属性，是无法通过

super调用的；在静态方法中，指向父类。

ES6 规定，在子类普通方法中通过super调用父类的方法时，方法内部的this指向当前的子类实例。

prototype和__proto__

（1）子类的__proto__属性，表示构造函数的继承，总是指向父类。

（2）子类prototype属性的__proto__属性，表示方法的继承，总是指向父类的prototype属性。