Comment vérifier si une classe Javascript hérite d'une autre (sans créer un obj) ?

Question

Eg :

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

Comment puis-je vérifier si la classe B hérite de la classe A ?

Answer 1

Essayez ce qui suit :

ChildClass.prototype instanceof ParentClass

Answer 2

Vous pouvez tester l'héritage direct avec

B.prototype.constructor === A

Pour tester l'héritage indirect, vous pouvez utiliser :

B.prototype instanceof A

(cette deuxième solution a été donnée pour la première fois par Nirvana Tikku)

Answer 3

Retour à 2017 :
Vérifiez si cela fonctionne pour vous

ParentClass.isPrototypeOf(ChildClass)

Alternative si vous voulez une protection contre l'ombrage :

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

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

Answer 4

Des problèmes : Notez que instanceof ne fonctionne pas comme prévu si vous utilisez plusieurs contextes/fenêtres d'exécution. Voir §§ .

---

En outre, par https://johnresig.com/blog/objectgetprototypeof/ il s'agit d'une mise en œuvre alternative qui est identique à celle de l'action de l'UE. instanceof :

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

La modifier pour vérifier directement la classe nous donne :

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

---

Sidenote

instanceof vérifie lui-même si obj.proto est f.prototype donc :

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

et :

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

et :

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

S'il n'est pas égal, le proto est échangé avec le proto du proto dans la vérification, puis le proto du proto du proto, et ainsi de suite. Ainsi :

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

et :

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

et :

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

Answer 5

Je ne pense pas que Simon voulait dire B.prototype = new A() dans sa question, car ce n'est certainement pas la façon de chaîner des prototypes en JavaScript.

En supposant que B prolonge A, utilisez Object.prototype.isPrototypeOf.call(A.prototype, B.prototype)