如何检查一个 Javascript 类是否继承了另一个(不创建 obj) ？

例如:

function A(){}
function B(){}
B.prototype = new A();

如何检查 B 类是否继承了 A 类？

41991 次浏览
小开

You can test direct inheritance with

B.prototype.constructor === A

To test indirect inheritance, you may use:

B.prototype instanceof A

(this second solution was first given by Nirvana Tikku)

小开
最佳答案

Try the following:

ChildClass.prototype instanceof ParentClass
小开

Gotchas: Note that instanceof does not work as expected if you use multiple execution contexts/windows. See §§.

Also, per https://johnresig.com/blog/objectgetprototypeof/, this is an alternative implementation that is identical to instanceof:

function f(_, C) { // instanceof Polyfill
while (_ != null) {
if (_ == C.prototype)
return true;
_ = _.__proto__;
}
return false;
}

Modifying it to check the class directly gives us:

function f(ChildClass, ParentClass) {
_ = ChildClass.prototype;
while (_ != null) {
if (_ == C.prototype)
return true;
_ = _.__proto__;
}
return false;
}

instanceof itself checks if obj.proto is f.prototype, thus:

function A(){};
A.prototype = Array.prototype;
[]instanceof Array // true

and:

function A(){}
_ = new A();
// then change prototype:
A.prototype = [];
/*false:*/ _ instanceof A
// then change back:
A.prototype = _.__proto__
_ instanceof A //true

and:

function A(){}; function B(){};
B.prototype=Object.prototype;
/*true:*/ new A()instanceof B

If it's not equal, proto is swapped with proto of proto in the check, then proto of proto of proto, and so on. Thus:

function A(){}; _ = new A()
_.__proto__.__proto__ = Array.prototype
g instanceof Array //true

and:

function A(){}
A.prototype.__proto__ = Array.prototype
g instanceof Array //true

and:

f=()=>{};
f.prototype=Element.prototype
document.documentElement instanceof f //true
document.documentElement.__proto__.__proto__=[];
document.documentElement instanceof f //false
小开

back to 2017:
check if that work for you

ParentClass.isPrototypeOf(ChildClass)

Alternative if you want protection against shadowing:

const isPrototypeOf = Function.call.bind(Object.prototype.isPrototypeOf);


// Usage:
isPrototypeOf(ParentClass, ChildClass); // true or false
小开

I do not think Simon meant B.prototype = new A() in his question, because this is certainly not the way to chain prototypes in JavaScript.

Assuming B extends A, use Object.prototype.isPrototypeOf.call(A.prototype, B.prototype)


提交答案