1. 对象的三种创建方式

在 JavaScript 中，创建对象的方式有如下三种方式：

（1）字面量方式

const obj = {};

（2）new 关键字

const obj = new Object();

（3）构造函数方式

function Person(name, age) {
    this.name = name;
    this.age = age;
}
const obj = new Person('Jack', 18);

new 的过程

新生成了一个对象
链接到原型
绑定this
返回新对象

在调用 new 的过程中会发生以上四件事情，可以自己实现一个 new：

function create() {
	// 创建一个空的对象
	let obj = new Object()
	// 获得构造函数
	let Con = [].shift.call(arguments)
	// 链接到原型
	obj.__proto__ = Con.prototype
	// 绑定 this，执行构造函数
	let result = Con.apply(obj, arguments)
	// 确保 new 出来的是个对象
	return typeof result === 'object' ? result : obj
}

2. 静态成员和实例成员

2.1 静态成员

静态成员是在构造函数本身上添加的成员，如下列代码中sex就是静态成员，静态成员只能通过构造函数来访问

function Obj(uname, age) {
    this.uname = uname;
    this.age = age;
    this.like = function () {
        console.log('我喜欢运动');
    };
}
Obj.sex = '男';
const usr = new Obj('Jack', 18);
console.log(Obj.sex); // 静态成员只能通过构造函数来访问

2.2 实例成员

实例成员就是构造函数内部通过this添加的成员，如下列代码中uname、age、sing就是实例成员，实例成员只能通过实例化的对象来访问。

function Star(uname, age) {
    this.uname = uname;
    this.age = age;
    this.do = function () {
        console.log('1234');
    };
}
const usr = new Star('Jack', 18);
console.log(usr.uname); //实例成员只能通过实例化的对象来访问

3. 构造函数的问题

构造函数方法很好用，但是存在浪费内存的问题。

function Star(uname, age) {
    this.uname = uname;
    this.age = age;
    this.do = function () {
        console.log('我会打篮球');
    };
}
const usr1 = new Star('Jack', 18);
const usr2 = new Star('Tom', 19);

4. 构造函数原型`prototype`

构造函数通过原型分配的函数是所有对象所共享的。

JavaScript 规定，每一个构造函数都有一个prototype属性，指向另一个对象。注意这个prototype就是一个对象，这个对象的所有属性和方法，都会被构造函数所拥有。

let fun = Function.prototype.bind()

如果以上述方法创建一个函数，那么可以发现这个函数是不具有prototype属性的。 {% endnote %}

我们可以把那些不变的方法，直接定义在prototype对象上，这样所有对象的实例就可以共享这些方法。

function Star(uname, age) {
    this.uname = uname;
    this.age = age;
}
Star.prototype.do = function () {
    console.log('我会打篮球');
};
const usr1 = new Star('Jack', 18);
const usr2 = new Star('Tom', 19);
usr1.do(); // 我会打篮球
usr2.do(); // 我会打篮球

5. 对象原型

对象都会有一个属性__proto__指向构造函数的prototype原型对象，之所以对象可以使用构造函数prototype原型对象的属性和方法，就是因为对象有__proto__原型的存在。

__proto__对象原型和原型对象prototype是等价的。

__proto__对象原型的意义就在于为对象的查找机制提供一个方向，或者说一条路线，但是它是一个非标准属性，因此实际开发中，不可以使用这个属性，它只是内部指向原型对象prototype。

function Star(uname, age) {
    this.uname = uname;
    this.age = age;
}
Star.prototype.do = function () {
    console.log('我会打篮球');
};
const usr1 = new Star('Jack', 18);
usr1.do(); // 我会打篮球
console.log(usr1.__proto__ == Star.prototype); // true

6. 构造函数`constructor`

对象原型（__proto__）和构造函数原型对象（prototype）里面都有一个constructor属性，称为构造函数，因为它指回构造函数本身。

constructor主要用于记录该对象引用于哪个构造函数，它可以让原型对象重新指向原来的构造函数。

注意： 一般情况下，对象的方法都在构造函数的原型对象中设置。如果有多个对象的方法，我们可以给原型对象采取对象形式赋值，但是这样就会覆盖构造函数原型对象原来的内容，这样修改后的原型对象constructor就不再指向当前构造函数了。此时，我们可以在修改后的原型对象中，添加一个constructor指向原来的构造函数。

如果我们修改了原来的原型对象，给原型对象赋值的是一个对象，则必须手动利用constructor指回原来的构造函数，如：

function Star(uname, age) {
    this.uname = uname;
    this.age = age;
}
// 很多情况下，我们需要手动的利用constructor这个属性指回，原来的构造函数
Star.prototype = {
    // 如果我们修改了原来的原型对象，给原型对象赋值的是一个对象，则必须手动利用constructor指回原来的构造函数
    constructor: Star, // 手动设置指回原来的构造函数
    do: function () {
        console.log('我会打篮球');
    },
    movie: function () {
        console.log('我喜欢看电影');
    },
};
const usr1 = new Star('Jack', 18);
console.log(usr1);

如果未设置constructor属性，如图：

7. 构造函数、实例、原型对象三角关系

构造函数的prototype属性指向了构造函数原型对象
实例对象是由构造函数创建的，实例对象的__proto__属性指向了构造函数的原型对象
构造函数的原型对象的constructor属性指向了构造函数，实例对象的原型的constructor属性（usr1. __proto__.constructor）也指向了构造函数

8. 原型链

每一个实例对象有一个__proto__属性，指向的构造函数的原型对象，构造函数的原型对象也是一个对象，也有__proto__属性，这样一层一层往上找就形成了原型链。

原型链查找机制：

当访问一个对象的属性（包括方法）时，首先查找这个对象自身有没有该属性。
如果没有就查找它的原型（也就是__proto__指向的prototype原型对象）。
如果还没有就查找原型对象的原型（Object的原型对象）。
依此类推一直找到Object为止（null）。
__proto__对象原型的意义就在于为对象成员查找机制提供一个方向，或者说一条路线。

总结：

Object 是所有对象的爸爸，所有对象都可以通过 __proto__ 找到它
Function 是所有函数的爸爸，所有函数都可以通过 __proto__ 找到它
Function.prototype 和 Object.prototype 是两个特殊的对象，他们由引擎来创建
除了以上两个特殊对象，其他对象都是通过构造器 new 出来的
函数的 prototype 是一个对象，也就是原型
对象的 __proto__ 指向原型， __proto__ 将对象和原型连接起来组成了原型链

9. 原型对象中`this`指向

构造函数中的this和原型对象的this，都指向new出来的实例对象。

function Stu(uname, age) {
    this.uname = uname;
    this.age = age;
    this.sing = function () {
        console.log('构造函数内部的this：', this);
    };
}
Stu.prototype.dance = function () {
    console.log('原型对象内部的this：', this);
};
const usr1 = new Stu('Jack', 18);
usr1.dance();
usr1.sing();

10. 通过原型为数组扩展内置方法

可以将自己写的方法，加到数组的原型对象上，这样每个数组实例，都可以调用这个方法。如下例子，写一个数组求和的函数，并添加到数组的原型对象上，每个数组实例都可以用sum()方法进行求和。

Array.prototype.sum = function () {
    let sum = 0;
    for (var i = 0; i < this.length; i++) {
        sum += this[i];
    }
    return sum;
};
//此时数组对象中已经存在sum()方法了，可以使用数组.sum()进行数据求和
const arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
console.log(arr.sum()); // 55

JavaScript构造函数与原型链解析｜8月更文挑战