【无标题】

原型和原型链

• 所有的函数都是通过new函数创建
• 所有函数都是对象 通过new Function创建
• 函数中可以有属性
• 所有对象都是引用类型

function test() { return {} }
new test() // {} new Object创建的

function test() {  }
new test() //test {}

typeof Object //'function'
typeof Array // 'function'

原型 prototype

可以理解 原型是通过new Object创建的
所有函数都有一个属性：prototype ,称之为函数原型 // 普通对象没有prototype
默认情况下，prototype是一个普通的Object对象 // prototype = { }
默认情况下，prototype中有一个属性，constructor， 他也是一个对象，它指向构造函数本身

var test =new Object()
test.prototype.constructor===test. //  true
Object.prototype.constructor===Object // true

引式原型 __ proto__

• 所有对象都有一个属性：__proto__,称之为隐式原型
• 默认情况下，隐式原型指向创建该对象的函数的原型

当访问一个对象的成员时：
1.看该对象自身是否拥有该成员，如果有直接使用；
2.看该对象的隐式原型是否拥有该成员，如果有直接使用；
3.在原型链中依次查找

猴子补丁：在函数原型中加入成员，以增强起对象的功能，猴子补丁会导致原型污染，使用需谨慎。

// 对象一定是通过构造函数产生 函数也是对象
function test() {  }
var obj = new test();
obj.__proto__ === test.prototype //true

var obj = new test();
obj.__proto__ === Object.prototype

* 函数都有一个属性 name
例如：如何得到创建obj的构造函数名称
function A(){}
function B(){}
function create(){
	if(Math.random()<0.5){
		return new A()
	}else{
		return new B()
	}
}

var obj = create()

obj.__proto__.constructor.name //"A"

举例
function User(name,age){
    this.name=name
    this.age=age
    this.sayHello=function(){
        return 'abc'
    }
}

var u1 = new User('u1name',1)
var u2 = new User('u2name',2)

u1.sayHello===u2.sayHello // false 指向不能的地址

function User(name,age){
    this.name=name
    this.age=age
}
User.prototype.sayHello = function(){console.log('111')}
u1.__proto__.sayHello===u2.__proto__.sayHello //true

原型链

每一个对象都有隐式原型，隐式原型的指向形成了一个链条；

function A(){}
var obj = new A()
obj.__proto__.__proto__.__proto__ // null

function A(){}
var A = new Function();
A.__proto__ === Funciton.prototype

特殊点：

• Function的__proto__ 指向自身的原型prototype
• Object的prototype的__proto__ 指向null