原型
JS声明构造函数(用来实例化对象的函数)时,会在内存中创建一个对应的对象,这个对象就是原函数的原型
原型规则
1. 所有的引用类型(数组、对象、函数)都具有对象特性,即可自由扩展属性(除了“null”以外)
var obj = {}; obj.a = 100;
var arr = []; arr.a = 100;
function fn() {}
fn.a = 100
2. 所有的引用类型(数组、对象、函数) 都有一个__proto__属性(隐式原型),属性值是一个普通的对象
// 继承1的代码
console.log(obj.__proto__)
console.log(arr.__proto__)
console.log(fn.__proto__)
3. 所有的函数都有一个prototype属性,属性值也是一个普通的对象
// 继承1的代码
console.log(fn.prototype)
4. 所有的引用类型(数组、对象、函数)的 __proto__ 属性值指向它的构造函数的 prototype 属性值
// 继承1的代码
console.log(obj.__proto__ === Object.prototype)
5. 当试图得到一个对象的某个属性时,如果这个对象本身没有这个属性,那么会去它的__proto__(即它的构造函数的prototype)中寻找
// 构造函数
function Foo(name) {
this.name = name
}
Foo.prototype.alertName = function() {
alert(this.name)
}
//创建实例
var f = new Foo('zhangsan')
f.printName = function() {
console.log(this.name)
}
// 测试
f.printName()
f.alertName() // 从Foo构造函数的prototype中寻找
原型链
当试图得到一个对象的某个属性时,如果这个对象本身没有这个属性,那么会去它的__proto__(即它的构造函数的prototype)中寻找,如果还没有找到 就会再构造函数的prototype的__proto__中寻找,这样一层一层向上寻找就会形成一个链式结构,我们成为原型链。
// 继承 5 的代码
f.toString() // 要去f.__proto__.__proto__中寻找
instanceof
f instanceof Foo 的判断逻辑是:f的__proto__一层一层往上,能否对应到Foo.prototype
同理 f instanceof Object 结果也是true, 只要在一条链上的都为true
f instanceof Foo // true
f instanceof Object // true
两个结果都是true, 那么怎么判断f 是从Foo生成的实例还是从Object生成的实例呢?接下来就要用到原型对象上的constructor属性了
f.__proto__.constructor === Foo // true
f.__proto__.constructor === Object // false
所以用constructor来判断比用instanceof更加严谨。
new运算符
原理:
1. 一个新对象被创建,它继承自foo.prototype
2. 构造函数foo被执行。执行的时候,相应的传参会被传入,同时上下文(this) 会被指定为这个新实例。
3. 执行结果如果返回了一个对象,那么这个对象会取代整个new出来的结果;如果没有返回对象,那么new出来的结果为步骤1创建的对象。
// 仿new原理
var new2 = function(fun) {
var obj = Object.create(fun.prototype)
var k = fun.call(obj)
if (typeof k === 'object') {
return k
}
return obj
}
var M = function(name) {this.name = name}
var o2 = new2(M)
console.log(o2 instanceof M) // true
console.log(o2 instanceof Object) // true
console.log(o2.__proto__.constructor === M) // true
M.prototype.walk = function(console.log('walk'))
o2.walk() // walk