Tutoriel d'apprentissage de l'opérateur de JavaScript

grammaire

 instance d'objet de constructeur

paramètre

objet:

L'objet à détecter.

constructeur:

Un constructeur

décrire:

L'opérateur d'instance OFF est utilisé pour détecter si le constructeur.prototype existe sur la chaîne prototype de l'objet paramètre.

 // définir la fonction du constructeur c () {} fonction d () {} var o = new C (); // true, car object.getPrototypeOf (o) === C.Prototypeo instanceof c; // FAUX, car D.Prototype n'est pas sur la chaîne prototype de O Instance Of D; o instanceof objet; // true, car object.prototype.isprototypeof (o) renvoie trueec.prototype instanceof object // true, identique à c.prototype = {}; var o2 = new C (); o2 instanceof c; // trueo instanceof c; // false, c.prototype pointe vers un objet vide, qui ne se trouve pas sur la chaîne prototype de O.D.Prototype = new C (); // hériter var o3 = new D (); o3 instanceof d; // trueo3 instanceof c; // vrai

Il convient de noter que si l'expression obj instance de foo renvoie true, cela ne signifie pas que l'expression renvoie pour toujours, car la valeur de la propriété foo.prototype peut changer, et la valeur modifiée peut ne pas exister sur la chaîne prototype OBJ, et la valeur de l'expression d'origine deviendra fausse. Dans un autre cas, la valeur de l'expression d'origine changera également, ce qui est le cas où la chaîne prototype de l'objet OBJ est modifiée. Bien que dans la spécification ES actuelle, nous ne pouvons lire le prototype de l'objet et ne pouvons pas le modifier, il peut être réalisé à l'aide de l'attribut magique __proto__ non standard. Par exemple, après avoir exécuté OBJ .__ Proto__ = {}, l'instance OBJ FOO renvoie False.

instanceof et objets multi-globaux (interaction entre plusieurs images ou plusieurs fenêtres)

Dans un navigateur, nos scripts peuvent avoir besoin d'interagir entre plusieurs fenêtres. Plusieurs fenêtres signifient plusieurs environnements globaux et différents environnements globaux ont des objets globaux différents, ayant ainsi différents constructeurs de type intégrés. Cela peut causer certains problèmes. Par exemple, l'expression [] instanceof window.frames [0] .Array reviendra false car array.prototype! == window.frames [0] .array.prototype, vous devez donc utiliser array.isArray (myObj) ou object.prototype.tostring.call (myobj) === "[objet Array]" pour déterminer si MyOBJ est un arroi.

Exemple

L'utilisation générale de l'instance est de déterminer si A est de type B:

 console.log (vraie instance de boolean); // false console.log (nouveau numéro (1) instance de numéro); // vrai

instanceof peut également déterminer le type de parent:

 fonction père () {} fonction child () {} child.prototype = new père (); var a = new child (); console.log (une instance de enfant); // trueconsole.log (un instance de père); // vrai

Le constructeur de l'enfant hérite du père. L'instance a est sans aucun doute construite par l'enfant, mais pourquoi est-ce aussi un exemple de père? En fait, le noyau de l'opérateur d'instance OFF peut être simplement décrit avec le code suivant:

 Fonction Check (a, b) {while (a .__ proto__) {if (a .__ proto__ === b.prototype) return true; a = a .__ proto__; } return false;} function foo () {} console.log (objet instance Off objet === Check (objet, objet)); // true console.log (fonction functionof function === Check (fonction, fonction)); // true console.log (numéro d'information de numéro === Check (numéro, numéro)); // true console.log (string instanceof string === Check (String, String)); // true console.log (function instanceof object === check (function, object)); // true console.log (foo instanceof function === check (foo, fonction)); // true console.log (foo instanceof foo === check (foo, foo)); // true console.log (foo instanceof foo === check (foo, foo)); // true console.log (foo instanceof foo === check (foo, foo)); // vrai

Autrement dit, si A est une instance de B, alors A peut certainement utiliser les méthodes et les propriétés définies dans le prototype de B. Ensuite, dans le code, cela signifie qu'il y a des objets avec la même valeur dans une chaîne prototype avec B.Protype, alors suivez simplement une chaîne prototype de A pour rechercher la couche par couche.

Il convient également de noter que le numéro de chaîne booléen et la fonction sont des fonctions et que les fonctions sont uniformément construites à partir de la fonction. Ils sont comme n'importe quelle fonction simple, et ils peuvent utiliser les propriétés prototypes de la fonction:

 Function.prototype.a = 10; console.log (String.a); // 10

Enfin, parlons brièvement des deux premières questions.

 // Pour le plaisir de la commodité de l'expression, distinguez d'abord l'expression gauche et l'expression droite fonctionl = fonction, functionr = function; // ci-dessous est progressivement déduit en fonction des spécifications o = functionr.prototype = function.prototype l = functionl .__ proto__ = function.prototype // premier jugement o == l // return true // Pour le plaisir de la commodité de l'expression, distingue d'abord l'expression gauche et l'expression droite Stringl = string, stringr = string; // ci-dessous est progressivement déduit en fonction des spécifications o = stringr.prototype = string.prototype l = stringl .__ proto__ = function.prototype // Les premiers juges o! = L // boucles à nouveau pour découvrir si l a encore __proto__ l = string.prototype .__ proto__ = objet.prototype // Le deuxième temps est-il o! = L // Loop __proto__ l = string.prototype .__ proto__ = null // Les juges de troisième fois l == null // return false