乐趣区

关于javascript:Js继承与原型链看这篇就够了

jiezi

继承与原型链
当谈到继承时，JavaScript 只有一种构造：对象。每个实例对象（object）都有一个公有属性（称之为 proto）指向它的构造函数的原型对象（prototype）。该原型对象也有一个本人的原型对象（proto），层层向上直到一个对象的原型对象为 null。依据定义，null 没有原型，并作为这个原型链中的最初一个环节。
简直所有 JavaScript 中的对象都是位于原型链顶端的 Object 的实例。
继承属性
JavaScript 对象是动静的属性“包”（指其本人的属性）。JavaScript 对象有一个指向一个原型对象的链。当试图拜访一个对象的属性时，它不仅仅在该对象上搜查，还会搜查该对象的原型，以及该对象的原型的原型，顺次层层向上搜寻，直到找到一个名字匹配的属性或达到原型链的开端。
代码实例
function fn() {
this.a = 1;
this.b = 2;
}

const o = new fn();

fn.prototype.b = 3;
fn.prototype.c = 4;
console.log(o.a);
console.log(o.b);
console.log(o.c);
console.log(o.d);
// 1
// 2
// 4
// undefined
复制代码

a 和 b 是 o 的本身属性能够间接返回值
为啥咱们设置 fn.prototype.b=3，返回的还是 2 呢？，因为咱们查找本身有这个属性时就间接返回了，不会在往上面查找了。
c 不是 o 的本身属性，所以会到 o.prototype 下来查找，发现有 c，间接返回值
d 不是 o 的本身属性，所以会到 o.prototype 下来查找，发现没有，再到 o.protype.prototype 上查找，发现为 null，进行搜寻，返回 undefined

看下 o 构造函数的打印
{

a: 1
b: 2
__proto__:
    b: 3
    c: 4
    constructor: ƒ fn()
    __proto__:
        constructor: ƒ Object()
        hasOwnProperty: ƒ hasOwnProperty()
        isPrototypeOf: ƒ isPrototypeOf()
        propertyIsEnumerable: ƒ propertyIsEnumerable()
        toLocaleString: ƒ toLocaleString()
        toString: ƒ toString()
        valueOf: ƒ valueOf()
        __defineGetter__: ƒ __defineGetter__()
        __defineSetter__: ƒ __defineSetter__()
        __lookupGetter__: ƒ __lookupGetter__()
        __lookupSetter__: ƒ __lookupSetter__()
        get __proto__: ƒ __proto__()
        set __proto__: ƒ __proto__()

}
复制代码
继承办法
JavaScript 并没有其余基于类的语言所定义的“办法”。在 JavaScript 里，任何函数都能够增加到对象上作为对象的属性。函数的继承与其余的属性继承没有差异，包含下面的“属性遮蔽”（这种状况相当于其余语言的办法重写）。
当继承的函数被调用时，this 指向的是以后继承的对象，而不是继承的函数所在的原型对象。
var o = {
a: 2,
m: function () {

return this.a + 1;

},
};

console.log(o.m()); // 3
// 当调用 o.m 时，’this’ 指向了 o.

var p = Object.create(o);
// p 是一个继承自 o 的对象

p.a = 4; // 创立 p 的本身属性 ‘a’
console.log(p.m()); // 5
// 调用 p.m 时，’this’ 指向了 p
// 又因为 p 继承了 o 的 m 函数
// 所以，此时的 ‘this.a’ 即 p.a，就是 p 的本身属性 ‘a’
复制代码
在 JavaScript 中应用原型
在 JavaScript 中，函数（function）是容许领有属性的。所有的函数会有一个特地的属性 —— prototype。默认状况下是 Object 的原型对象
function doSomething() {}
console.log(doSomething.prototype);
// 和申明函数的形式无关，
// JavaScript 中的函数永远有一个默认原型属性。
var doSomething = function () {};
console.log(doSomething.prototype);
复制代码
在控制台显示的 JavaScript 代码块中，咱们能够看到 doSomething 函数的一个默认属性 prototype。而这段代码运行之后，控制台应该显示相似如下的后果：
{

constructor: ƒ doSomething(),
__proto__: {constructor: ƒ Object(),
    hasOwnProperty: ƒ hasOwnProperty(),
    isPrototypeOf: ƒ isPrototypeOf(),
    propertyIsEnumerable: ƒ propertyIsEnumerable(),
    toLocaleString: ƒ toLocaleString(),
    toString: ƒ toString(),
    valueOf: ƒ valueOf()}

}
复制代码
咱们能够给 doSomething 函数的原型对象增加新属性，如下：
function doSomething() {}
doSomething.prototype.foo = “bar”;
console.log(doSomething.prototype);
复制代码
能够看到运行后的后果如下：

{

foo: "bar",
constructor: ƒ doSomething(),
__proto__: {constructor: ƒ Object(),
    hasOwnProperty: ƒ hasOwnProperty(),
    isPrototypeOf: ƒ isPrototypeOf(),
    propertyIsEnumerable: ƒ propertyIsEnumerable(),
    toLocaleString: ƒ toLocaleString(),
    toString: ƒ toString(),
    valueOf: ƒ valueOf()}

}
复制代码
当初咱们能够通过 new 操作符来创立基于这个原型对象的 doSomething 实例。
代码：
function doSomething() {}
doSomething.prototype.foo = “bar”; // add a property onto the prototype
var doSomeInstancing = new doSomething();
doSomeInstancing.prop = “some value”; // add a property onto the object
console.log(doSomeInstancing);
复制代码
运行的后果相似于以下的语句。
{

prop: "some value",
__proto__: {
    foo: "bar",
    constructor: ƒ doSomething(),
    __proto__: {constructor: ƒ Object(),
        hasOwnProperty: ƒ hasOwnProperty(),
        isPrototypeOf: ƒ isPrototypeOf(),
        propertyIsEnumerable: ƒ propertyIsEnumerable(),
        toLocaleString: ƒ toLocaleString(),
        toString: ƒ toString(),
        valueOf: ƒ valueOf()}
}

}
复制代码
咱们能够看到 prop 是 doSomeInstancing 的本身属性，doSomeInstancing 中的 proto 就是 doSomething.prototype
咱们打印下外面的属性
console.log(“doSomeInstancing.prop: ” + doSomeInstancing.prop);
console.log(“doSomeInstancing.foo: ” + doSomeInstancing.foo);
console.log(“doSomething.prop: ” + doSomething.prop);
console.log(“doSomething.foo: ” + doSomething.foo);
console.log(“doSomething.prototype.prop: ” + doSomething.prototype.prop);
console.log(“doSomething.prototype.foo: ” + doSomething.prototype.foo);
复制代码
后果如下：
// doSomeInstancing 的本身属性，间接返回值
doSomeInstancing.prop: some value
// 不是 doSomeInstancing 的本身属性，查看原型对象，发现有这个属性间接返回值
doSomeInstancing.foo: bar
// 不是函数本身的属性，也不是原型对象上的属性，一层层往上找，最初查找到 prototype 为 null 时，示意没有这个属性，所以返回 undefined
doSomething.prop: undefined
doSomething.foo: undefined
doSomething.prototype.prop: undefined
// 查找 doSomething 原型对象有 foo 属性，所以间接返回值
doSomething.prototype.foo: bar
复制代码
性能
在原型链上查找属性比拟耗时，对性能有副作用，这在性能要求刻薄的状况下很重要。另外，试图拜访不存在的属性时会遍历整个原型链。
遍历对象的属性时，原型链上的每个可枚举属性都会被枚举进去。要查看对象是否具备本人定义的属性，而不是其原型链上的某个属性，则必须应用所有对象从 Object.prototype 继承的 hasOwnProperty 办法。上面给出一个具体的例子来阐明它：
console.log(doSomeInstancing.hasOwnProperty(“prop”));
// true

console.log(doSomeInstancing.hasOwnProperty(“bar”));
// false

console.log(doSomeInstancing.hasOwnProperty(“foo”));
// false

console.log(doSomeInstancing.__proto__.hasOwnProperty(“foo”));
// true
复制代码
hasOwnProperty 是 JavaScript 中惟一一个解决属性并且不会遍历原型链的办法。
另一种这样的办法：Object.keys()
留神：查看属性是否为 undefined 是不可能查看其是否存在的。该属性可能已存在，但其值恰好被设置成了 undefined。
https://zhuanlan.zhihu.com/p/…
https://zhuanlan.zhihu.com/p/…
https://zhuanlan.zhihu.com/p/…
https://zhuanlan.zhihu.com/p/…
https://zhuanlan.zhihu.com/p/…
https://zhuanlan.zhihu.com/p/…
https://zhuanlan.zhihu.com/p/…
https://zhuanlan.zhihu.com/p/…
https://zhuanlan.zhihu.com/p/…

退出移动版