1.constructor关键字
constructor关键字用于在类定义块内部创建类的构造函数。
方法名constructor会告诉解释器在使用new操作符创建类的新实例时，应该调用这个函数。
构造函数的定义不是必需的，不定义构造函数详单与将构造函数定义为空函数。
2.实例化
使用new操作符实例化Person的操作等于使用new调用其构造函数。
JavaScript解释器知道使用new和类意味着应该使用constructor函数进行实例化。
使用new调用类的构造函数会执行如下操作。
（1）在内存中创建一个新对象。
（2）这个新对象内部的[[Prototype]]指针被赋值为构造函数的prototype属性。
（3）构造函数内部的this被赋值为这个新对象。
（4）执行构造函数内部的代码。
（5）如果构造函数返回非空对象，则返回该对象；否则，返回刚创建的新对象。
class Person{
constructor(name){
console.log(arguments.length);
this.name = name || null;
}
}

let p1 = new Person;//0
console.log(p1.name);//null

let p2 = new Person();//0
console.log(p2.name);//null

let p3 = new Person(‘Jake’);//1
console.log(p3.name);//Jake
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
类实例化时传入的参数会用作构造函数的参数，如果不需要参数，则类名后面的括号也是可选的。
class Person{
constructor(override){
this.foo = ‘foo’;
if(override){
return{
bar:‘bar’
}
}
}
}

let p1 = new Person(),
p2 = new Person(true);

console.log(p1);//Person {foo: “foo”}
console.log(p1 instanceof Person);//true

console.log(p2);//{bar: “bar”}
console.log(p2 instanceof Person);//false
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
如果返回的不是this对象，而是其他对象，那么这个对象不会通过instanceof操作符检测出跟类有关联。
function Person(){};
class Animal{}

let p = Person();//将window作为内部对象
let a = Animal();//TypeError: Class constructor Animal cannot be invoked without 'new’
1
2
3
4
5
普通构造函数如果不使用new调用，那么就会以全局的this（通常是window）作为内部对象。
调用类构造函数时如果忘了使用new则会抛出错误。
2.把类当成特殊函数
class Person{}

console.log(Person);//class Person{}
console.log(typeof Person);//function
1
2
3
4
从各方面来看，ECMAScript类就是一种特殊函数。
class Person{}

console.log(Person.prototype);//{constructor:f()}
console.log(Person === Person.prototype.constructor);//true

let p = new Person();
console.log(p instanceof Person);//true
1
2
3
4
5
6
7
8
类标识符有prototype属性，而这个原型也有一个constructor属性指向类自身。.
可以使用类标识符来检查构造函数原型是否存在于实例的原型链中。
class Person{};
let p1 = new Person();

console.log(p1.constructor === Person);//true
console.log(p1 instanceof Person);//true
console.log(p1 instanceof Person.constructor);//false

let p2 = new Person.constructor();

console.log(p2.constructor === Person);//false
console.log(p2 instanceof Person);//false
console.log(p2 instanceof Person.constructor);//true
1
2
3
4
5
6
7
8
9
10
11
12
在类的上下文中，类本身在使用new调用时就会被当成构造函数。重点在于，类中定义的constructor方法不会被当成构造函数，在对它使用instanceof操作符时会返回false。如果在创建实例时直接将构造函数当成普通函数来使用，那么instanceof操作符的返回值会反转。
let classList = [
class{
constructor(id){
this.id_ = id;
console.log(instance ${this.id_})
}
}
];
function createInstance(classDefinition,id){
return new classDefinition(id);
}
let foo = createInstance(classList[0],3141);//instance 3141
1
2
3
4
5
6
7
8
9
10
11
12
可以像其他对象或函数引用一样把类作为参数传递。
let p = new class Foo{
constructor(x){
console.log(x);
}
}(‘bar’);//bar
console.log§//Foo{}
1
2
3
4
5
6
与立即调用函数表达式相似，类也可以立即实例化。
————————————————
版权声明：本文为CSDN博主「木子 旭」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_45895576/article/details/118882241