创建对象、原型、原型链
主要摘自《Javascript高级程序设计》
创建对象的方法
- 工厂模式
- 构造函数
- 原型链
- 组合（构造函数和原型链）
- 寄生构造函数模式
- 委托构造函数模式
工厂模式
var person = function(name,age){
var o = new Object();
o.name = name;
o.age = age;
o.sayName = function() {
console.log(this.name)
}
return o;
}
var person1 = person('li', 20);
var person2 = person('xiao', 18);
person1.sayName(); //li
person2.sayName(); //xiao
- 先创建一个object
- object绑定属性和方法
- 返回这个object
缺点
工厂模式虽然解决了创建多个相似对象的问题，但是却没有解决对象识别的问题，即怎样知道一个对象的类型。
构造函数
var Person = function(name,age) {
this.name = name;
this.age = age;
this.sayName = function() {
console.log(this.name)
}
}
var person1 = new Person('li',20)
var person2 = new Person('xiao',18)
person1.sayName() //li
person2.sayName() //xiao
构造函数和工厂函数不同之处在于：
- 没有显示的创建对象
- 直接将属性和方法赋给了this对象
- 没有return语句
- 函数名的首字母大写
- 要创建构造函数的实例，必须使用new操作符
** 调用构造函数会经历下面4个步骤（即new干了什么）**：
- 创建一个新对象
- 将构造函数的作用域赋给新对象（因此this指向了这个新对象）
- 执行构造函数中的代码（为这个新对象添加属性）
- 返回新对象
上面的person1和person2分别保存Person的一个不同实例，这两个对象都有一个constructor（构造函数）属性，该属性执行Person
person1.constructor == person2.constructor == Person
可以用constructor来识别对象类型，但是用instanceof 更可靠
person1和person2同时也是object的实例，因为所有的对象都继承自Object
缺点
如果构造函数里面有方法，那方法都会在每个实例上都创建一遍，因此不同实例上的函数是不相等的
person1.sayName == person2.sayName // false
虽然可以把方法移到构造函数外部，设置成全局函数，但是如果对象需要定义很多方法，就要定义很多个全局函数，
原型模式
function Person(){};
Person.prototype.name = "li";
Person.prototype.age = 20;
Person.prototype.sayName = function(){
console.log(this.name)
};
var person1 = new Person()
var person2 = new Person()
person1.sayName() //li
person2.sayName() //li
person2.name = 'xiao' //person2这个实例加了一个name属性，重写name属性，但不会改变原型的值
person1.sayName() //li
person2.sayName() //xiao //如果实例上有name属性，取的是实例上的
好处
可以让所有对象实例共享它所包含的属性和方法。
person1.sayName !== person2.sayName //true
原型对象
只要创建了一个函数，就会为该函数创建一个prototype属性，这个属性指向函数的原型对象。在默认情况下，所有原型对象都会自动获得一个constructor（构造函数）属性，这个属性包含一个指向prototype属性所在函数的指针(妈呀，很拗口，看代码和图比较直观)
创建了自定义的构造函数后，其原型对象默认只会取得constructor属性，至于其他方法，都是从object继承而来。当调用构造函数创建一个实例，该实例内部将包含一个指针，指向构造函数的原型对象，可以用_proto_属性访问。这个链接存在与实例与构造函数的原型对象之间，而不存在于实例与构造函数之间。
Person.prototype.constructor = Person
person1._proto_ == Person.prototype
判断是不是对象的原型
- isPrototypeOf
Person.prototype.isPrototypeOf(person1) // true
- Object.getPrototypeOf可以取到一个实例的原型
Object.getPrototypeOf(person1) == Person.prototype // true
Object.getPrototypeOf(person1).name //li
判断一个属性是存在实例中还是原型中
- hasOwnProperty（）只在给定属性存在实例中时，才返回true
person1.hasOwnProperty('name') // false
person2.hasOwnProperty('name') //true
- in 不管属性是存在实例上还是原型中，都返回true
'name' in Person // true
hasOwnProperty和in一起可以判断属性是不是在原型中
!object.hasOwnProperty(name) && ('name' in object)
对象字面量
我们将Person.prototype 设置为等于一个以对象字面量形式创建的新对象，最终结果相同，但是constructor属性不再指向Person。这里的语法，本质上完成重写了默认的portotype对象，因此它的原型是Object，constructor是指向Object的构造函数。但是用instanceof 操作符还能返回正确结果
function Person(){};
Person.prototype = {
name: 'li',
age: 20,
sayName: function(){
console.log(this.name)
}
};
var person1 = new Person()
console.log(Person.prototype.constructor == Person) //false
console.log(Person.prototype.constructor == Object) //true
console.log(person1 instanceof Person) // true
原型的动态性
function Person(){};
var person1 = new Person()
Person.prototype = {
name: 'li',
age: 20,
sayName: function(){
console.log(this.name)
}
};
person1.sayName() //person1.sayName is not a function
先创建实例，在重写其原型对象，会切断现有原型与之前任何已经存在的对象实例之间的联系。person1引用的还是原来的原型。可以用下面这种写法
function Person(){};
var person1 = new Person()
Person.prototype.sayName = function(name){
console.log(name)
}
person1.sayName('li') //li
原型对象的缺点
- 省略了为构造函数传递初始化参数，所有实例在默认情况下都取得相同的属性值。
- 如果有引用类型的属性，会导致在一个实例里修改引用类型的值，会把原型上的也修改了
组合使用构造函数模式和原型模式
- 构造函数模式用于定义实例属性
- 原型模式用于定义方法和共享的属性
var Person = function(name,age) {
this.name = name;
this.age = age;
}
Person.prototype.sayName = function(){
console.log(this.name)
};
var person1 = new Person('li',20)
var person2 = new Person('xiao',18)
person1.sayName() //li
person2.sayName() //xiao
- 动态原型模式
function Person(name, age){
this.name = name;
this.age = age
if(typeof this.sayName != function) {
Person.prototype.sayName = function(name){
console.log(this.name)
}
}
};
判断这个代码只会在初次调用构造函数时执行
- 寄生构造函数模式
- 委托构造函数模式 不引用this
继承
js只支持实现继承 主要是依靠 原型链 来实现的.
利用原型让一个引用类型继承另一个引用类型的属性和方法
方法：
- 原型链
- 借用构造函数
- 组合继承
- 原型式继承
- 寄生式继承
- 寄生组合式继承
原型链
每一个构造函数都有一个原型对象，原型对象包含一个指向构造函数的指针，而实例都包含一个指向原型对象的指针。那么，如果我们让原型对象等于另一个类型的实例，此时的原型对象将包含一个指向另一个原型的指针，相应的，另一个原型中也包含着一个指向另一个构造函数的指针，假如另一个原型又是另一个类型的实例。。。如此层层递进，就构成了实例和原型的链条
如果引用对象(实例instance)的某个属性，会现在这个对象内找，如果找不到，就会到这个对象的原型上去找，原型上找不到，就到原型的原型上去找，直到找到这个属性或者返回null为止
function Parent(name) {
this.name = name
}
Parent.prototype.sayName = function() {
console.log(this.name)
}
function Children(age) {
this.age = age
}
Children.prototype = new Parent('Amy') //子类的原型是父类的实例
let instance = new Children(10)
instance.sayName()
借用构造函数
在子类型构造函数的内部调用超类型构造函数
缺点
无法复用函数，所有类型只能使用构造函数模式
组合继承
原型链和借用构造函数组合，使用原型链实现对原型属性和方法的继承，通过借用构造函数来实现对实例属性的继承
function Parent(name) {
this.name = name
this.colors = ['red']
}
Parent.prototype.sayName = function() {
console.log(this.name)
}
function Children(name,age) {
Parent.call(this,name);
this.age = age
}
Children.prototype = new Parent()
let instance1 = new Children('Amy',10)
instance1.sayName()
instance1.colors.push('green')
console.log(instance1.colors)
let instance2 = new Children('Mike',20)
instance2.sayName()
instance2.colors.push('blue')
console.log(instance2.colors)
缺点
调用两次超类型构造函数，
原型式继承
function object(o) {
function F(){};
F.prototype = o; //F的原型指向传入的对象o
return new F()
}
Object.create(),这个方法接收两个参数，一个是用作新对象原型的对象和（可选）一个为新对象定义额外属性的对象，只有一个参数时，Object.create()与Objec()一样
包含引用类型值的属性始终都会共享相应的值
寄生式继承
创建一个仅用于封装继承过程的函数。不能做到函数复用
寄生组合式继承
通过借用构造函数来实现对实例属性的继承，通过原型链的混成模式来继承方法。仅调用一次超类型构造函数，避免创建不必要的多余的属性
function Parent(name) {
this.name = name;
this.colors = ['yellow']
}
Parent.prototype.sayName = function() {
console.log(this.name)
}
function Children(name,age) {
Parent.call(this,name);
this.age = age
}
function inheritPrototype(parent,children) {
var prototype = Object(parent.prototype)
prototype.constructor = children;
children.prototype = prototype
}
inheritPrototype(Parent, Children);
var instance1 = new Children('li', 20)
instance1.sayName()
es6的继承和es5有什么不同
ES5 的继承，实质是先创造子类的实例对象this，然后再将父类的方法添加到this上面（Parent.apply(this)）。ES6 的继承机制完全不同，实质是先将父类实例对象的属性和方法，加到this上面（所以必须先调用super方法），然后再用子类的构造函数修改this。
如果子类没有定义constructor方法，这个方法会被默认添加，在子类的构造函数中，只有调用super之后，才可以使用this关键字，否则会报错。这是因为子类实例的构建，基于父类实例，只有super方法才能调用父类实例。
转载自:https://juejin.cn/post/6844903860121632781