Exemples Expliquez l'utilisation de l'instance d'opérateur en JavaScript

Introduction à l'instance de l'opérateur

Dans JavaScript, en jugeant le type d'une variable, vous utiliserez l'opérateur de type. Lorsque vous utilisez l'opérateur Typeof, vous aurez un problème à utiliser un type de référence pour stocker la valeur. Peu importe le type d'objet référencé, il renverra "objet". ECMAScript introduit une autre instance d'opérateur Java pour résoudre ce problème. L'opérateur d'instance OFF est similaire à l'opérateur de type et est utilisé pour identifier le type d'objet traité. Contrairement à la méthode TypeOf, la méthode d'instance OFF nécessite que le développeur confirme explicitement que l'objet est un type spécifique. Par exemple:

Listing 1. Exemple d'instance

 var stringObject = new String ("Hello World"); console.log (stringObject instanceOf String); // Sortie "True"

Ce code demande "La variable OstRingObject est-elle une instance de l'objet String?" OstringObject est en effet une instance de l'objet String, donc le résultat est "vrai". Bien qu'il ne soit pas aussi flexible que la méthode TypeOf, la méthode d'instance OFF est utile lorsque la méthode TypeOf renvoie "Objet".

Utilisation générale de l'instance de l'opérateur:

D'une manière générale, l'utilisation de l'instance est de déterminer si une instance appartient à un certain type. Par exemple:

Listing 2. Utilisation générale de l'instance

 // Déterminez si FOO est une instance de la fonction de classe foo foo () {} var foo = new foo (); console.log (foo instanceof foo) // true

De plus, un point plus lourd est que l'instance de l'instance peut être utilisée dans les relations d'héritage pour déterminer si une instance appartient à son type de parent. Par exemple:

Listing 3. Utilisation de l'instance de relations dans les successions

 // Déterminez si FOO est une instance de la classe FOO et s'il s'agit d'une instance de sa fonction de type parent aoo () {} fonction foo () {} foo.prototype = new AOO (); // javascript prototype héritage var foo = new foo (); console.log (foo instanceof foo) // true console.log (foo instanceof aoo) // true

Dans le code ci-dessus, la classe des parents dans une couche de relation d'héritage est jugée. Dans la relation d'hérédité multicouches, l'opérateur d'instance est également applicable.

Comprenez-vous vraiment l'instance d'opérateur?

Après avoir lu l'exemple de code ci-dessus, pensez-vous que l'opérateur d'instance est très simple? Jetons un coup d'œil à une utilisation compliquée.

Listing 4. instance de l'utilisation complexe

 console.log (objet objet objet); // true console.log (fonction functionof function); // true console.log (numéro d'instance de numéro); // false console.log (string instanceof string); // false console.log (fonction de fonction de la fonction de la fonction console.log (foo instance foo);

Êtes-vous à nouveau confus après avoir lu le code ci-dessus? Pourquoi l'instance d'objet et de fonction eux-mêmes est-elle égale, tandis que d'autres instances elles-mêmes ne sont pas égales vraies? Comment l'expliquer? Pour comprendre fondamentalement le mystère de l'instance, nous devons commencer à partir de deux aspects: 1. Comment définir cet opérateur dans la spécification linguistique. 2. Mécanisme de succession du prototype JavaScript.

Listing 5. Instance JavaScript du code d'opérateur

 function instance_of (l, r) {// l représente l'expression gauche, R représente l'expression droite var o = r.prototype; // prendre le prototype d'affichage de r l = l .__ proto __; // prendre le prototype implicite de L while (true) {if (l === null) return false; si (o === l) // voici le point: quand o est strictement égal à l, retourne vrai; L = l .__ proto__; }}

Listing 6. instance d'objet Off objet

 // Par souci de commodité de l'expression, distinguez d'abord l'expression gauche et l'expression droite ObjectL = objet, objecttr = objet; // Ce qui suit consiste à déduire progressivement O = objectR.prototype = object.prototype l = objet .__ proto__ = function.prototype // Le premier jugement est o! = L // boucle pour trouver si l a toujours __proto__ l = fonction.prototype .__ proto__ = objet.prototype // Le deuxième jugement o == l // Retour.

Listing 7. Fonction Instance de fonction

 // Pour le plaisir de la commodité de l'expression, distinguez d'abord l'expression gauche et l'expression droite fonctionl = fonction, functionr = function; // Ce qui suit est de déduire progressivement o = functionr.prototype = function.prototype l = functionl .__ proto__ = function.prototype // Le premier jugement o == l // return true

Listing 8. Foo Instance de FOO

 // Par souci de commodité de l'expression, distinguez d'abord l'expression gauche et l'expression droite Fool = Foo, Foor = Foo; // Ce qui suit est de déduire progressivement en fonction des spécifications o = foor.prototype = foo.prototype l = fool .__ proto__ = function.prototype // Le premier jugement est o! = L // Le premier jugement est o! = L // Le cycle est de trouver si l a toujours __proto__ l = fonction. Le cycle consiste à découvrir si l a toujours __proto__ l = objet.prototype .__ proto__ = null // Le troisième jugement l == null // return false

Analyser brièvement l'application de l'instance de l'offre dans le mécanisme de succession du dojo

En JavaScript, il n'y a pas de concept d'héritage multiple, tout comme Java. Cependant, lors de la déclaration des cours dans DOJO, l'héritage de plusieurs classes est autorisé. Prenons un exemple Dojo 1.6.1.

Listing 9. héritage multiple dans le dojo

 dojo.declare ("aoo", null, {}); dojo.declare ("boo", null, {}); dojo.declare ("foo", [aoo, boo], {}); var foo = new foo (); console.log (foo instanceof aoo); // true console.log (foo instanceof boo); // false console.log (foo.isinstanceof (aoo)); // true console.log (foo.isinstance (boo)); // true console.log (foo.isinstanceof (boo)); // true console.log (foo.isinstanceof (boo)); // true console.log (foo.isinstanceof (boo)); // true console.log (Foo.isinstanceOf (BOO)); // true

Dans l'exemple ci-dessus, FOO hérite de AOO et BOO, mais lors de l'utilisation de l'opérateur d'instance pour vérifier si FOO est une instance de BOO, il renvoie False. En fait, à l'intérieur de Dojo, FOO hérite toujours uniquement de AOO et utilise le mécanisme de mixin pour copier les méthodes et les propriétés de la classe BOO pour FOO. Par conséquent, lorsque l'opérateur d'instance OFF est utilisé pour vérifier s'il s'agit d'une instance de BOO, FALSE sera retourné. Dojo ajoute donc une nouvelle méthode appelée IsInstanceof pour chaque instance de classe et utilise cette méthode pour vérifier plusieurs héritages.