构造函数的缺点
- js 通过构造函数生成新对象
function OutFun (name,gender){ this.name=name this.gender=gender } var fun = new OutFun('小明','女') console.log(fun.name)
- OutFun函数是一个构造函数，OutFun函数内部定义了name属性和gender属性。实例对象上都会有这两个属性，
- 属性定义到实例上，但有一个缺点。就是同一个构造函数的多个实例之间是无法共享属性。造成资源的浪费
function OutFun (name,gender){ this.name=name this.gender=gender this.innerFun = function (){ console.log('this') } } var fun = new OutFun('小明','女') var fun1 = new OutFun('小明','女') console.log(fun.innerFun===fun1.innerFun)//false
- 可以看出fun和fun1虽然是同一个构造函数但其实是两个实例。他们实例上都有innerFun 。我们每实例化的时候就创建一个新的innerFun。那怎么共享innerFun？那么就用到下面的原型对象prototype了
原型对象prototype
- js继承，就是原型对象中的所有属性和方法，都能被实例对象共享。js中每一个函数都有prototype，prototype其实就是一个object。
console.log(typeof OutFun.prototype)//object-
对于普通函数，prototype没有太大作用。但对于构造函数，生成实例的时候该属性会自动成为实例对象的原型。
function OutFun(){ this.age='33' } OutFun.prototype.name='小明' OutFun.prototype.age='44' var fun=new OutFun() console.log(fun.name)//小明 console.log(fun.gender)//undefined console.log(fun.age)//33 我们在访问name属性的时候。实例对象上没有该属性或方法,它就回去原型对象去找该属性或方法.若实例对象上有则不去原型对象上找。若原型对象上也没有该属性和方法。那么就去原型的原型找，还找不到就去原型的原型的原型找，直到找到Object.prototype还没有，就返回undefined
注意，要找某个属性会一级级向上，对性能也是有影响的。这就意味着，如果这个属性根本不存在，那么我们就得再整条原型链里查找一边。对性能的开销也越大。原型对象:定义实例对象共享的属性和方法。
-
原型链
-
原型链：js中所有对象都有自己的原型对象（prototype）。任何对象都可以充当其他对象的原型。原型本身也是对象，所以它也有自己的原型。那么就形成了---原型链（对象，对象的原型，对象原型的原型……）
对象的原型最终到Object.prototype（null）。所有对象都可以继承原型（prototype）上的属性Object.getPrototypeOf(Object.prototype)//nullObject.getPrototypeOf方法返回参数对象的原型
image.png
eg：让构造函数中原型对象指向一个数组，这就意味着我们这个实例对象就可以使用数组的方法
function OutFun(){}
OutFun.prototype=new Array()
var fun = new OutFun()
fun.push(1,2,3)
console.log(fun.length)//3
console.log(fun instanceof Array)//true--------------------instanceof 判断一个对象是否为某个构造函数的实例
instanceof运算符
- 判断一个对象是否为某个构造函数的实例
- X instanceof S -----------------------X对象，S构造函数。instanceof 检查右边S构造函数的原型对象（prototype），是否在左边对象的原型链上。
于S.prototype.isPrototypeOf(X)一样。
function OutFun(){}
var fun=new OutFun()
console.log(fun instanceof OutFun)//true----表示该fun实例对象是OutFun构造函数的实例
- instanceof检查整条原型链，同一个实例对象，可能会对多个构造函数都返回true。
var arr=new Array()
console.log(arr instanceof Array)//true
console.log(arr instanceof Object)//true
- 任意对象（null除外）都是Object的实例，所以instanceof运算符可以判断是否为非null
var obj = { name: 'xiaoming' };
var arr = new Array()
console.log(obj instanceof Object)// true
console.log(null instanceof Object)// false
console.log(arr instanceof Object)// true
- instanceof运算符只能用于对象，不适用基本数据类型的值
var num = 2342;
console.log(num instanceof Number) // false
var str = '2342';
console.log(str instanceof Number) // false
var isTrue = true
console.log(isTrue instanceof Number) // false
var und = undefined
console.log(und instanceof Number) // false
- 利用instanceof运算符，解决调用构造函数时，忘了加new命令的问题。
function Fubar (foo, bar) {
if (this instanceof Fubar) {//this是否是构造函数的实例，如果不是则没有new
this._foo = foo;
this._bar = bar;
} else {
return new Fubar(foo, bar);
}
}
constructor 属性
- prototype对象有一个constructor属性，默认指向prototype对象所在的构造函数。
function OutFun(){}
//默认指向prototype所在的构造函数--可知道我们要想知道这个实例对象是那个构造函数产生的
console.log(OutFun.prototype.constructor===OutFun)//true
//改变OutFun的原型对象，那么constructor的指向也跟着改变了---constructor属性表示原型对象与构造函数之间的关联关系，如果修改了原型对象，会同时修改constructor属性，防止引用的时候出错。
OutFun.prototype=new Array()
console.log(OutFun.prototype.constructor===OutFun)//false
//手动改变constructor
OutFun.prototype.contructor=OutFun
console.log(OutFun.prototype.constructor===OutFun)//false
- 既然constructor是prototype的属性，那么表示constructor可以被所有实例对象继承
- 我们可以从constructor调用构造函数。相当于调用自身的构造函数。
function OutFun(){}
var fun=new OutFun()
var funCon = new fun.constructor()
console.log(funCon instanceof OutFun)//true
- 通过name属性，从实例得到构造函数的名称。
function OutFun(){}
var fun=new OutFun()
console.log(fun.constructor.name)//OutFun
构造函数的继承
- 子类是整体继承父类
- 第一步是在子类的构造函数中，调用父类的构造函数。
- 第二步，是让子类的原型指向父类的原型，这样子类就可以继承父类原型。
//首先我们先定义父类
function Parent(){
this.num = 0
}
Parent.prototype.sum = function(num){
this.num +=num
}
//子构造函数
function Son(){
Parent.call(this)//调用父类构造函数
}
Son.prototype = Object.create(Parent.prototype)//子类继承父类的原型
Son.prototype.constructor = Son
var son = new Son()
son.sum(3)
son.sum(5)
console.log(son.num)
- 子继承父类的单个方法
//定义父类
function Parent(){
this.num = 0
}
Parent.prototype.sum = function(num){
console.log(num,'num')
this.num += num
}
//子构造函数
function Son(){
Parent.call(this)//调用父类构造函数
}
Son.prototype.sum=function(){
Parent.prototype.sum.call(this,3)
}
var son = new Son()
son.sum()
son.sum()
console.log(son)//6
console.log(son instanceof Son)//false
console.log(son instanceof Parent)//false
