创意活动策划网站,工作组赴哈尔滨,php语言网站开发,什么样的企业要做网站Class 的基本语法
类的由来[constructor() 方法](https://es6.ruanyifeng.com/#docs/class#constructor() 方法)类的实例实例属性的新写法取值函数#xff08;getter#xff09;和存值函数#xff08;setter#xff09;属性表达式[Class 表达式](https://es6.ruanyifeng.c…Class 的基本语法
类的由来[constructor() 方法](https://es6.ruanyifeng.com/#docs/class#constructor() 方法)类的实例实例属性的新写法取值函数getter和存值函数setter属性表达式[Class 表达式](https://es6.ruanyifeng.com/#docs/class#Class 表达式)静态方法静态属性私有方法和私有属性静态块类的注意点[new.target 属性](https://es6.ruanyifeng.com/#docs/class#new.target 属性)
类的由来
JavaScript 语言中生成实例对象的传统方法是通过构造函数。下面是一个例子。
function Point(x, y) {this.x x;this.y y;
}Point.prototype.toString function () {return ( this.x , this.y );
};var p new Point(1, 2);上面这种写法跟传统的面向对象语言比如 C 和 Java差异很大很容易让新学习这门语言的程序员感到困惑。
ES6 提供了更接近传统语言的写法引入了 Class类这个概念作为对象的模板。通过class关键字可以定义类。
基本上ES6 的class可以看作只是一个语法糖它的绝大部分功能ES5 都可以做到新的class写法只是让对象原型的写法更加清晰、更像面向对象编程的语法而已。上面的代码用 ES6 的class改写就是下面这样。
class Point {constructor(x, y) {this.x x;this.y y;}toString() {return ( this.x , this.y );}
}上面代码定义了一个“类”可以看到里面有一个constructor()方法这就是构造方法而this关键字则代表实例对象。这种新的 Class 写法本质上与本章开头的 ES5 的构造函数Point是一致的。
Point类除了构造方法还定义了一个toString()方法。注意定义toString()方法的时候前面不需要加上function这个关键字直接把函数定义放进去了就可以了。另外方法与方法之间不需要逗号分隔加了会报错。
ES6 的类完全可以看作构造函数的另一种写法。
class Point {// ...
}typeof Point // function
Point Point.prototype.constructor // true上面代码表明类的数据类型就是函数类本身就指向构造函数。
使用的时候也是直接对类使用new命令跟构造函数的用法完全一致。
class Bar {doStuff() {console.log(stuff);}
}const b new Bar();
b.doStuff() // stuff构造函数的prototype属性在 ES6 的“类”上面继续存在。事实上类的所有方法都定义在类的prototype属性上面。
class Point {constructor() {// ...}toString() {// ...}toValue() {// ...}
}// 等同于Point.prototype {constructor() {},toString() {},toValue() {},
};上面代码中constructor()、toString()、toValue()这三个方法其实都是定义在Point.prototype上面。
因此在类的实例上面调用方法其实就是调用原型上的方法。
class B {}
const b new B();b.constructor B.prototype.constructor // true上面代码中b是B类的实例它的constructor()方法就是B类原型的constructor()方法。
由于类的方法都定义在prototype对象上面所以类的新方法可以添加在prototype对象上面。Object.assign()方法可以很方便地一次向类添加多个方法。
class Point {constructor(){// ...}
}Object.assign(Point.prototype, {toString(){},toValue(){}
});prototype对象的constructor属性直接指向“类”的本身这与 ES5 的行为是一致的。
Point.prototype.constructor Point // true另外类的内部所有定义的方法都是不可枚举的non-enumerable。
class Point {constructor(x, y) {// ...}toString() {// ...}
}Object.keys(Point.prototype)
// []
Object.getOwnPropertyNames(Point.prototype)
// [constructor,toString]上面代码中toString()方法是Point类内部定义的方法它是不可枚举的。这一点与 ES5 的行为不一致。
var Point function (x, y) {// ...
};Point.prototype.toString function () {// ...
};Object.keys(Point.prototype)
// [toString]
Object.getOwnPropertyNames(Point.prototype)
// [constructor,toString]上面代码采用 ES5 的写法toString()方法就是可枚举的。
constructor() 方法
constructor()方法是类的默认方法通过new命令生成对象实例时自动调用该方法。一个类必须有constructor()方法如果没有显式定义一个空的constructor()方法会被默认添加。
class Point {
}// 等同于
class Point {constructor() {}
}上面代码中定义了一个空的类PointJavaScript 引擎会自动为它添加一个空的constructor()方法。
constructor()方法默认返回实例对象即this完全可以指定返回另外一个对象。
class Foo {constructor() {return Object.create(null);}
}new Foo() instanceof Foo
// false上面代码中constructor()函数返回一个全新的对象结果导致实例对象不是Foo类的实例。
类必须使用new调用否则会报错。这是它跟普通构造函数的一个主要区别后者不用new也可以执行。
class Foo {constructor() {return Object.create(null);}
}Foo()
// TypeError: Class constructor Foo cannot be invoked without new类的实例
生成类的实例的写法与 ES5 完全一样也是使用new命令。前面说过如果忘记加上new像函数那样调用Class()将会报错。
class Point {// ...
}// 报错
var point Point(2, 3);// 正确
var point new Point(2, 3);类的属性和方法除非显式定义在其本身即定义在this对象上否则都是定义在原型上即定义在class上。
class Point {constructor(x, y) {this.x x;this.y y;}toString() {return ( this.x , this.y );}
}var point new Point(2, 3);point.toString() // (2, 3)point.hasOwnProperty(x) // true
point.hasOwnProperty(y) // true
point.hasOwnProperty(toString) // false
point.__proto__.hasOwnProperty(toString) // true上面代码中x和y都是实例对象point自身的属性因为定义在this对象上所以hasOwnProperty()方法返回true而toString()是原型对象的属性因为定义在Point类上所以hasOwnProperty()方法返回false。这些都与 ES5 的行为保持一致。
与 ES5 一样类的所有实例共享一个原型对象。
var p1 new Point(2,3);
var p2 new Point(3,2);p1.__proto__ p2.__proto__
//true上面代码中p1和p2都是Point的实例它们的原型都是Point.prototype所以__proto__属性是相等的。
这也意味着可以通过实例的__proto__属性为“类”添加方法。 __proto__ 并不是语言本身的特性这是各大厂商具体实现时添加的私有属性虽然目前很多现代浏览器的 JS 引擎中都提供了这个私有属性但依旧不建议在生产中使用该属性避免对环境产生依赖。生产环境中我们可以使用 Object.getPrototypeOf() 方法来获取实例对象的原型然后再来为原型添加方法/属性。 var p1 new Point(2,3);
var p2 new Point(3,2);p1.__proto__.printName function () { return Oops };p1.printName() // Oops
p2.printName() // Oopsvar p3 new Point(4,2);
p3.printName() // Oops上面代码在p1的原型上添加了一个printName()方法由于p1的原型就是p2的原型因此p2也可以调用这个方法。而且此后新建的实例p3也可以调用这个方法。这意味着使用实例的__proto__属性改写原型必须相当谨慎不推荐使用因为这会改变“类”的原始定义影响到所有实例。
实例属性的新写法
ES2022 为类的实例属性又规定了一种新写法。实例属性现在除了可以定义在constructor()方法里面的this上面也可以定义在类内部的最顶层。
// 原来的写法
class IncreasingCounter {constructor() {this._count 0;}get value() {console.log(Getting the current value!);return this._count;}increment() {this._count;}
}上面示例中实例属性_count定义在constructor()方法里面的this上面。
现在的新写法是这个属性也可以定义在类的最顶层其他都不变。
class IncreasingCounter {_count 0;get value() {console.log(Getting the current value!);return this._count;}increment() {this._count;}
}上面代码中实例属性_count与取值函数value()和increment()方法处于同一个层级。这时不需要在实例属性前面加上this。
注意新写法定义的属性是实例对象自身的属性而不是定义在实例对象的原型上面。
这种新写法的好处是所有实例对象自身的属性都定义在类的头部看上去比较整齐一眼就能看出这个类有哪些实例属性。
class foo {bar hello;baz world;constructor() {// ...}
}上面的代码一眼就能看出foo类有两个实例属性一目了然。另外写起来也比较简洁。
取值函数getter和存值函数setter
与 ES5 一样在“类”的内部可以使用get和set关键字对某个属性设置存值函数和取值函数拦截该属性的存取行为。
class MyClass {constructor() {// ...}get prop() {return getter;}set prop(value) {console.log(setter: value);}
}let inst new MyClass();inst.prop 123;
// setter: 123inst.prop
// getter上面代码中prop属性有对应的存值函数和取值函数因此赋值和读取行为都被自定义了。
存值函数和取值函数是设置在属性的 Descriptor 对象上的。
class CustomHTMLElement {constructor(element) {this.element element;}get html() {return this.element.innerHTML;}set html(value) {this.element.innerHTML value;}
}var descriptor Object.getOwnPropertyDescriptor(CustomHTMLElement.prototype, html
);get in descriptor // true
set in descriptor // true上面代码中存值函数和取值函数是定义在html属性的描述对象上面这与 ES5 完全一致。
属性表达式
类的属性名可以采用表达式。
let methodName getArea;class Square {constructor(length) {// ...}[methodName]() {// ...}
}上面代码中Square类的方法名getArea是从表达式得到的。
Class 表达式
与函数一样类也可以使用表达式的形式定义。
const MyClass class Me {getClassName() {return Me.name;}
};上面代码使用表达式定义了一个类。需要注意的是这个类的名字是Me但是Me只在 Class 的内部可用指代当前类。在 Class 外部这个类只能用MyClass引用。
let inst new MyClass();
inst.getClassName() // Me
Me.name // ReferenceError: Me is not defined上面代码表示Me只在 Class 内部有定义。
如果类的内部没用到的话可以省略Me也就是可以写成下面的形式。
const MyClass class { /* ... */ };采用 Class 表达式可以写出立即执行的 Class。
let person new class {constructor(name) {this.name name;}sayName() {console.log(this.name);}
}(张三);person.sayName(); // 张三上面代码中person是一个立即执行的类的实例。
静态方法
类相当于实例的原型所有在类中定义的方法都会被实例继承。如果在一个方法前加上static关键字就表示该方法不会被实例继承而是直接通过类来调用这就称为“静态方法”。
class Foo {static classMethod() {return hello;}
}Foo.classMethod() // hellovar foo new Foo();
foo.classMethod()
// TypeError: foo.classMethod is not a function上面代码中Foo类的classMethod方法前有static关键字表明该方法是一个静态方法可以直接在Foo类上调用Foo.classMethod()而不是在Foo类的实例上调用。如果在实例上调用静态方法会抛出一个错误表示不存在该方法。
注意如果静态方法包含this关键字这个this指的是类而不是实例。
class Foo {static bar() {this.baz();}static baz() {console.log(hello);}baz() {console.log(world);}
}Foo.bar() // hello上面代码中静态方法bar调用了this.baz这里的this指的是Foo类而不是Foo的实例等同于调用Foo.baz。另外从这个例子还可以看出静态方法可以与非静态方法重名。
父类的静态方法可以被子类继承。
class Foo {static classMethod() {return hello;}
}class Bar extends Foo {
}Bar.classMethod() // hello上面代码中父类Foo有一个静态方法子类Bar可以调用这个方法。
静态方法也是可以从super对象上调用的。
class Foo {static classMethod() {return hello;}
}class Bar extends Foo {static classMethod() {return super.classMethod() , too;}
}Bar.classMethod() // hello, too静态属性
静态属性指的是 Class 本身的属性即Class.propName而不是定义在实例对象this上的属性。
class Foo {
}Foo.prop 1;
Foo.prop // 1上面的写法为Foo类定义了一个静态属性prop。
目前只有这种写法可行因为 ES6 明确规定Class 内部只有静态方法没有静态属性。现在有一个提案提供了类的静态属性写法是在实例属性的前面加上static关键字。
class MyClass {static myStaticProp 42;constructor() {console.log(MyClass.myStaticProp); // 42}
}这个新写法大大方便了静态属性的表达。
// 老写法
class Foo {// ...
}
Foo.prop 1;// 新写法
class Foo {static prop 1;
}上面代码中老写法的静态属性定义在类的外部。整个类生成以后再生成静态属性。这样让人很容易忽略这个静态属性也不符合相关代码应该放在一起的代码组织原则。另外新写法是显式声明declarative而不是赋值处理语义更好。
私有方法和私有属性
早期解决方案
私有方法和私有属性是只能在类的内部访问的方法和属性外部不能访问。这是常见需求有利于代码的封装但早期的 ES6 不提供只能通过变通方法模拟实现。
一种做法是在命名上加以区别。
class Widget {// 公有方法foo (baz) {this._bar(baz);}// 私有方法_bar(baz) {return this.snaf baz;}// ...
}上面代码中_bar()方法前面的下划线表示这是一个只限于内部使用的私有方法。但是这种命名是不保险的在类的外部还是可以调用到这个方法。
另一种方法就是索性将私有方法移出类因为类内部的所有方法都是对外可见的。
class Widget {foo (baz) {bar.call(this, baz);}// ...
}function bar(baz) {return this.snaf baz;
}上面代码中foo是公开方法内部调用了bar.call(this, baz)。这使得bar()实际上成为了当前类的私有方法。
还有一种方法是利用Symbol值的唯一性将私有方法的名字命名为一个Symbol值。
const bar Symbol(bar);
const snaf Symbol(snaf);export default class myClass{// 公有方法foo(baz) {this[bar](baz);}// 私有方法[bar](baz) {return this[snaf] baz;}// ...
};上面代码中bar和snaf都是Symbol值一般情况下无法获取到它们因此达到了私有方法和私有属性的效果。但是也不是绝对不行Reflect.ownKeys()依然可以拿到它们。
const inst new myClass();Reflect.ownKeys(myClass.prototype)
// [ constructor, foo, Symbol(bar) ]上面代码中Symbol 值的属性名依然可以从类的外部拿到。
私有属性的正式写法
ES2022正式为class添加了私有属性方法是在属性名之前使用#表示。
class IncreasingCounter {#count 0;get value() {console.log(Getting the current value!);return this.#count;}increment() {this.#count;}
}上面代码中#count就是私有属性只能在类的内部使用this.#count。如果在类的外部使用就会报错。
const counter new IncreasingCounter();
counter.#count // 报错
counter.#count 42 // 报错上面示例中在类的外部读取或写入私有属性#count都会报错。
另外不管在类的内部或外部读取一个不存在的私有属性也都会报错。这跟公开属性的行为完全不同如果读取一个不存在的公开属性不会报错只会返回undefined。
class IncreasingCounter {#count 0;get value() {console.log(Getting the current value!);return this.#myCount; // 报错}increment() {this.#count;}
}const counter new IncreasingCounter();
counter.#myCount // 报错上面示例中#myCount是一个不存在的私有属性不管在函数内部或外部读取该属性都会导致报错。
注意私有属性的属性名必须包括#如果不带#会被当作另一个属性。
class Point {#x;constructor(x 0) {this.#x x;}get x() {return this.#x;}set x(value) {this.#x value;}
}上面代码中#x就是私有属性在Point类之外是读取不到这个属性的。由于井号#是属性名的一部分使用时必须带有#一起使用所以#x和x是两个不同的属性。
这种写法不仅可以写私有属性还可以用来写私有方法。
class Foo {#a;#b;constructor(a, b) {this.#a a;this.#b b;}#sum() {return this.#a this.#b;}printSum() {console.log(this.#sum());}
}上面示例中#sum()就是一个私有方法。
另外私有属性也可以设置 getter 和 setter 方法。
class Counter {#xValue 0;constructor() {console.log(this.#x);}get #x() { return this.#xValue; }set #x(value) {this.#xValue value;}
}上面代码中#x是一个私有属性它的读写都通过get #x()和set #x()操作另一个私有属性#xValue来完成。
私有属性不限于从this引用只要是在类的内部实例也可以引用私有属性。
class Foo {#privateValue 42;static getPrivateValue(foo) {return foo.#privateValue;}
}Foo.getPrivateValue(new Foo()); // 42上面代码允许从实例foo上面引用私有属性。
私有属性和私有方法前面也可以加上static关键字表示这是一个静态的私有属性或私有方法。
class FakeMath {static PI 22 / 7;static #totallyRandomNumber 4;static #computeRandomNumber() {return FakeMath.#totallyRandomNumber;}static random() {console.log(I heard you like random numbers…)return FakeMath.#computeRandomNumber();}
}FakeMath.PI // 3.142857142857143
FakeMath.random()
// I heard you like random numbers…
// 4
FakeMath.#totallyRandomNumber // 报错
FakeMath.#computeRandomNumber() // 报错上面代码中#totallyRandomNumber是私有属性#computeRandomNumber()是私有方法只能在FakeMath这个类的内部调用外部调用就会报错。
in 运算符
前面说过直接访问某个类不存在的私有属性会报错但是访问不存在的公开属性不会报错。这个特性可以用来判断某个对象是否为类的实例。
class C {#brand;static isC(obj) {try {obj.#brand;return true;} catch {return false;}}
}上面示例中类C的静态方法isC()就用来判断某个对象是否为C的实例。它采用的方法就是访问该对象的私有属性#brand。如果不报错就会返回true如果报错就说明该对象不是当前类的实例从而catch部分返回false。
因此try...catch结构可以用来判断某个私有属性是否存在。但是这样的写法很麻烦代码可读性很差ES2022 改进了in运算符使它也可以用来判断私有属性。
class C {#brand;static isC(obj) {if (#brand in obj) {// 私有属性 #brand 存在return true;} else {// 私有属性 #foo 不存在return false;}}
}上面示例中in运算符判断某个对象是否有私有属性#brand。它不会报错而是返回一个布尔值。
这种用法的in也可以跟this一起配合使用。
class A {#foo 0;m() {console.log(#foo in this); // true}
}注意判断私有属性时in只能用在类的内部。另外判断所针对的私有属性一定要先声明否则会报错。
class A {m() {console.log(#foo in this); // 报错}
}上面示例中私有属性#foo没有声明就直接用于in运算符的判断导致报错。
子类从父类继承的私有属性也可以使用in运算符来判断。
class A {#foo 0;static test(obj) {console.log(#foo in obj);}
}class SubA extends A {};A.test(new SubA()) // true上面示例中SubA从父类继承了私有属性#fooin运算符也有效。
注意in运算符对于Object.create()、Object.setPrototypeOf形成的继承是无效的因为这种继承不会传递私有属性。
class A {#foo 0;static test(obj) {console.log(#foo in obj);}
}
const a new A();const o1 Object.create(a);
A.test(o1) // false
A.test(o1.__proto__) // trueconst o2 {};
Object.setPrototypeOf(o2, a);
A.test(o2) // false
A.test(o2.__proto__) // true上面示例中对于修改原型链形成的继承子类都取不到父类的私有属性所以in运算符无效。
静态块
静态属性的一个问题是如果它有初始化逻辑这个逻辑要么写在类的外部要么写在constructor()方法里面。
class C {static x 234;static y;static z;
}try {const obj doSomethingWith(C.x);C.y obj.yC.z obj.z;
} catch {C.y ...;C.z ...;
}上面示例中静态属性y和z的值依赖于静态属性x的运算结果这段初始化逻辑写在类的外部上例的try...catch代码块。另一种方法是写到类的constructor()方法里面。这两种方法都不是很理想前者是将类的内部逻辑写到了外部后者则是每次新建实例都会运行一次。
为了解决这个问题ES2022 引入了静态块static block允许在类的内部设置一个代码块在类生成时运行且只运行一次主要作用是对静态属性进行初始化。以后新建类的实例时这个块就不运行了。
class C {static x ...;static y;static z;static {try {const obj doSomethingWith(this.x);this.y obj.y;this.z obj.z;}catch {this.y ...;this.z ...;}}
}上面代码中类的内部有一个 static 代码块这就是静态块。它的好处是将静态属性y和z的初始化逻辑写入了类的内部而且只运行一次。
每个类允许有多个静态块每个静态块中只能访问之前声明的静态属性。另外静态块的内部不能有return语句。
静态块内部可以使用类名或this指代当前类。
class C {static x 1;static {this.x; // 1// 或者C.x; // 1}
}上面示例中this.x和C.x都能获取静态属性x。
除了静态属性的初始化静态块还有一个作用就是将私有属性与类的外部代码分享。
let getX;export class C {#x 1;static {getX obj obj.#x;}
}console.log(getX(new C())); // 1上面示例中#x是类的私有属性如果类外部的getX()方法希望获取这个属性以前是要写在类的constructor()方法里面这样的话每次新建实例都会定义一次getX()方法。现在可以写在静态块里面这样的话只在类生成时定义一次。
类的注意点
严格模式
类和模块的内部默认就是严格模式所以不需要使用use strict指定运行模式。只要你的代码写在类或模块之中就只有严格模式可用。考虑到未来所有的代码其实都是运行在模块之中所以 ES6 实际上把整个语言升级到了严格模式。
不存在提升
类不存在变量提升hoist这一点与 ES5 完全不同。
new Foo(); // ReferenceError
class Foo {}上面代码中Foo类使用在前定义在后这样会报错因为 ES6 不会把类的声明提升到代码头部。这种规定的原因与下文要提到的继承有关必须保证子类在父类之后定义。
{let Foo class {};class Bar extends Foo {}
}上面的代码不会报错因为Bar继承Foo的时候Foo已经有定义了。但是如果存在class的提升上面代码就会报错因为class会被提升到代码头部而定义Foo的那一行没有提升导致Bar继承Foo的时候Foo还没有定义。
name 属性
由于本质上ES6 的类只是 ES5 的构造函数的一层包装所以函数的许多特性都被Class继承包括name属性。
class Point {}
Point.name // Pointname属性总是返回紧跟在class关键字后面的类名。
Generator 方法
如果某个方法之前加上星号*就表示该方法是一个 Generator 函数。
class Foo {constructor(...args) {this.args args;}* [Symbol.iterator]() {for (let arg of this.args) {yield arg;}}
}for (let x of new Foo(hello, world)) {console.log(x);
}
// hello
// world上面代码中Foo类的Symbol.iterator方法前有一个星号表示该方法是一个 Generator 函数。Symbol.iterator方法返回一个Foo类的默认遍历器for...of循环会自动调用这个遍历器。
this 的指向
类的方法内部如果含有this它默认指向类的实例。但是必须非常小心一旦单独使用该方法很可能报错。
class Logger {printName(name there) {this.print(Hello ${name});}print(text) {console.log(text);}
}const logger new Logger();
const { printName } logger;
printName(); // TypeError: Cannot read property print of undefined上面代码中printName方法中的this默认指向Logger类的实例。但是如果将这个方法提取出来单独使用this会指向该方法运行时所在的环境由于 class 内部是严格模式所以 this 实际指向的是undefined从而导致找不到print方法而报错。
一个比较简单的解决方法是在构造方法中绑定this这样就不会找不到print方法了。
class Logger {constructor() {this.printName this.printName.bind(this);}// ...
}另一种解决方法是使用箭头函数。
class Obj {constructor() {this.getThis () this;}
}const myObj new Obj();
myObj.getThis() myObj // true箭头函数内部的this总是指向定义时所在的对象。上面代码中箭头函数位于构造函数内部它的定义生效的时候是在构造函数执行的时候。这时箭头函数所在的运行环境肯定是实例对象所以this会总是指向实例对象。
还有一种解决方法是使用Proxy获取方法的时候自动绑定this。
function selfish (target) {const cache new WeakMap();const handler {get (target, key) {const value Reflect.get(target, key);if (typeof value ! function) {return value;}if (!cache.has(value)) {cache.set(value, value.bind(target));}return cache.get(value);}};const proxy new Proxy(target, handler);return proxy;
}const logger selfish(new Logger());new.target 属性
new是从构造函数生成实例对象的命令。ES6 为new命令引入了一个new.target属性该属性一般用在构造函数之中返回new命令作用于的那个构造函数。如果构造函数不是通过new命令或Reflect.construct()调用的new.target会返回undefined因此这个属性可以用来确定构造函数是怎么调用的。
function Person(name) {if (new.target ! undefined) {this.name name;} else {throw new Error(必须使用 new 命令生成实例);}
}// 另一种写法
function Person(name) {if (new.target Person) {this.name name;} else {throw new Error(必须使用 new 命令生成实例);}
}var person new Person(张三); // 正确
var notAPerson Person.call(person, 张三); // 报错上面代码确保构造函数只能通过new命令调用。
Class 内部调用new.target返回当前 Class。
class Rectangle {constructor(length, width) {console.log(new.target Rectangle);this.length length;this.width width;}
}var obj new Rectangle(3, 4); // 输出 true需要注意的是子类继承父类时new.target会返回子类。
class Rectangle {constructor(length, width) {console.log(new.target Rectangle);// ...}
}class Square extends Rectangle {constructor(length, width) {super(length, width);}
}var obj new Square(3); // 输出 false上面代码中new.target会返回子类。
利用这个特点可以写出不能独立使用、必须继承后才能使用的类。
class Shape {constructor() {if (new.target Shape) {throw new Error(本类不能实例化);}}
}class Rectangle extends Shape {constructor(length, width) {super();// ...}
}var x new Shape(); // 报错
var y new Rectangle(3, 4); // 正确上面代码中Shape类不能被实例化只能用于继承。
注意在函数外部使用new.target会报错。
