web-dev-qa-db-fra.com

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

Par exemple:

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

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

javascriptclassinheritance
59
Simon

essayez ceci B.prototype instanceof A

102
Nirvana Tikku

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)

23
Denys Séguret

retour à 2017:
vérifier si cela fonctionne pour vous 

A.isPrototypeOf(B)
14
pery mimon

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

De plus, pour https://johnresig.com/blog/objectgetprototypeof/ , il s'agit d'une implémentation alternative identique à instanceof:

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

Le modifier pour vérifier la classe directement 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, ainsi:

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

Si ce n'est pas égal, proto est échangé avec proto de proto dans le test, puis proto de proto de proto, etc. 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
1
Pacerier

Je ne pense pas que Simon ait voulu dire B.prototype = new A() dans sa question, car ce n’est certainement pas le moyen de chaîner des prototypes en JavaScript.

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

0
jlchereau