Comment vérifier si un Javascript Classe hérite d'une autre (sans la création d'un obj)?

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?

InformationsquelleAutor Simon | 2013-01-23
  1. 113

    donner à ceci un essai B.prototype instanceof A

    • Qu'en est ES6 class ? class A extends B{} alors comment puis-je vérifier les héritages de la classe A
    • classe de syntaxe est surtout juste que: un spécial syntaxe. Derrière les scènes de la gestion réelle des "classes" n'a pas changé et donc vous pouvez toujours travailler avec A.prototype ... developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/...
    InformationsquelleAutor Nirvana Tikku
  2. 27

    Vous pouvez tester l'héritage direct avec

    B.prototype.constructor === A

    De test indirect à l'héritage, vous pouvez utiliser

    B.prototype instanceof A

    (cette deuxième solution a d'abord été donnée par Nirvana Tikku)

    • Pas que seulement la classe parent, pas tout le patrimoine de la chaîne.
    • Juste restauré. Grâce dystroy (pour la mise à jour de cette réponse, aussi)
    InformationsquelleAutor Denys Séguret
  3. 17

    retour à 2017:

    vérifier si ce travail pour vous 

    A.isPrototypeOf(B)
    InformationsquelleAutor pery mimon
  4. 1

    Pièges: Noter que instanceof ne fonctionne pas comme prévu si vous utilisez plusieurs contextes d'exécution/windows. Voir §§.

    Aussi, par https://johnresig.com/blog/objectgetprototypeof/, c'est une alternative qui est identique à instanceof:

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

    En le modifiant pour vérifier la classe directement nous donne:

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

    Note

    instanceof lui-même vérifie 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

    Si ce n'est pas l'égalité, le proto est échangé avec le proto proto dans la case, puis proto proto proto, et ainsi de suite. Donc:

    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
    InformationsquelleAutor Pacerier
  5. 1

    Je ne pense pas que Simon signifiait B.prototype = new A() dans sa question, parce que ce n'est certainement pas la voie à la chaîne de prototypes en JavaScript.

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

    InformationsquelleAutor jlchereau