Nous savons que l'opérateur instanceof est utilisé pour vérifier si un objet est une instance d'un constructeur. Les différents scénarios dans lesquels il renvoie vrai sont répertoriés ci-dessous.
1. L'objet obj est créé via un nouveau constructeur, alors l'instance obj du constructeur est vraie
Copiez le code comme suit :
fonction Personne(n, a) {
this.name = n;
cet.age = a;
}
var p = nouvelle personne ('John Backus', 82);
console.log(p instance de Personne); // vrai
2. S'il existe une relation d'héritage, alors l'instance de la sous-classe et la classe parent renverront également true.
Copiez le code comme suit :
fonction A(){}
fonction B(){}
B.prototype = new A(); // B hérite de A
var b = nouveau B();
console.log (b instance de A); // vrai
3. Puisque Object est la classe racine, toutes les autres classes personnalisées en héritent, donc l'instance d'Object de n'importe quel constructeur renvoie true.
Copiez le code comme suit :
fonction A() {}
var a = nouveau A();
console.log (une instance d'objet); // vrai
var str = new String('bonjour');
console.log(str instanceof Object); // vrai
var num = nouveau numéro (1);
console.log (nombre d'instances d'objet); // vrai
Même le constructeur lui-même
Copiez le code comme suit :
fonction A() {}
console.log (une instance d'objet); // vrai
console.log (instance de chaîne d'objet); // vrai
console.log (Nombre d'instances d'objet); // vrai
4. Tous les constructeurs instanceof Function renvoient true
Copiez le code comme suit :
fonction A() {}
console.log (une instance de fonction); // vrai
console.log (chaîne instance de fonction); // vrai
console.log (numéro d'instance de fonction); // vrai
Les quatre points ci-dessus sont résumés en une phrase : Si une instance est créée par une certaine classe ou sa sous-classe, alors instanceof renvoie true. Ou si le prototype d'un certain constructeur existe sur la chaîne de prototypes interne de l'objet obj, alors true est renvoyé. Autrement dit, le résultat de instanceof n'a aucune relation directe avec le constructeur lui-même. Ceci est courant dans de nombreuses langues.
Une classe Person est définie en Java et l'instance p renvoie true à la fois pour Person et Object.
Copiez le code comme suit :
classe Personne {
nom de chaîne publique ;
âge public int ;
Personne (Chaîne n, int a) {
this.name = nom ;
cet.age = a;
}
public static void main (String[] arguments) {
Personne p = nouvelle Personne("John Backus", 82);
System.out.println(p instanceof Person); // vrai
System.out.println (p instance d'objet); // vrai
}
}
S'il existe une relation d'héritage en Java, alors l'instance de la classe parent de la sous-classe renvoie également true.
Copiez le code comme suit :
// classe parent
classe Personne {
nom de chaîne publique ;
âge public int ;
Personne (Chaîne n, int a) {
nom = nom ;
âge = un ;
}
}
// sous-classe
classe publique L'homme étend la personne {
université publique String;
Homme (Chaîne n, int a, Chaîne s) {
super(n, une);
université = s;
}
public static void main (String[] arguments) {
Homme mm = nouveau Homme("John Resig", 29, "PCU");
System.out.println(mm instanceof Man); // vrai
System.out.println(mm instanceof Person); // également vrai
}
}
Sachant cela, les performances suivantes en JS ne sont pas surprenantes
Copiez le code comme suit :
//Définit deux constructeurs
fonction A(){}
fonction B(){}
A.prototype = B.prototype = {a : 1} ;
//Créer respectivement deux instances de constructeurs différents
var a = nouveau A();
var b = nouveau B();
console.log (une instance de B); // vrai
console.log (b instance de A); // vrai
Nous voyons que a et b sont créés respectivement avec A et B, mais a instanceof B et b instanceof A sont vraies. Autrement dit, même si a n’est pas créé avec le constructeur B, il renvoie toujours vrai. Parce que B.prototype existe sur la chaîne de prototypes interne de a.
En raison des caractéristiques dynamiques du langage JS, le prototype peut être modifié au moment de l'exécution, il n'est donc pas surprenant que ce qui suit renvoie faux. Parce que A.prototype n'est plus dans la chaîne de prototypes interne de a, la chaîne est interrompue.
Copiez le code comme suit :
fonction A(){}
var a = nouveau A();
A.prototype = {}; // Modifier dynamiquement le prototype, veuillez noter que cela doit être fait après avoir créé un
console.log (une instance de A); // faux
Notez qu'écrire ceci rompt également le premier point résumé ci-dessus : l'objet obj est créé via un nouveau constructeur, alors obj instanceof Constructor est vrai
En fait, dans le standard ECMAScript (sous réserve de 5.1), l'implémentation interne d'instanceof appellera la méthode interne [[HasInstance]] du constructeur, qui est décrite comme suit
Si F est un objet fonction, lorsque F(V) est exécuté, les étapes suivantes se produiront :
1. Si l'opérande gauche V de instanceof n'est pas un type d'objet, renvoyez directement false.
Copiez le code comme suit :
var a, b = 1, c = vrai, d = 'bonjour';
console.log (une instance d'objet); // false ici, une valeur n'est pas définie
console.log (b instance d'objet); // faux
console.log (c instance d'objet); // faux
console.log(d instanceof Object); // false
2/3. Récupérez l'attribut prototype du constructeur F. S'il ne s'agit pas d'un type d'objet, une exception TypeError doit être levée.
Copiez le code comme suit :
fonction A(){}
A.prototype = 1; // Définit le prototype de A sur un type non-objet
var a = nouveau A();
console.log (une instance de A);
Les invites d'exception émises par chaque navigateur sont différentes.
Firefox18 :
Chrome24 :
Safari6 :
Opéra12 :
IE10 :
4. Exécutez en continu la logique suivante : définissez V sur le V du prototype interne, renvoyez false si V est nul et renvoyez true si V et O pointent tous deux vers le même objet.