Ejemplos Explique el uso de la instancia del operador en JavaScript

Introducción a la instancia del operador

En JavaScript, a juzgar el tipo de variable, utilizará el operador de typeOf. Cuando use el operador TypeOf, tendrá un problema utilizando un tipo de referencia para almacenar el valor. No importa a qué tipo de objeto se haga referencia, devolverá el "objeto". ECMAScript presenta otra instancia de operador Java para resolver este problema. El Operador de instancia de es similar al Operador TypeOf y se utiliza para identificar el tipo de objeto que se está procesando. A diferencia del método typeof, el método de instancia de la que requiere que el desarrollador confirme explícitamente que el objeto es un tipo específico. Por ejemplo:

Listado 1. Instancia de ejemplo

 var ostringObject = new String ("Hello World"); console.log (OstringObject instancia de cadena); // Salida "Verdadero"

Este código pregunta "¿Es la variable OstringObject una instancia del objeto String?" OstringObject es de hecho una instancia del objeto de cadena, por lo que el resultado es "verdadero". Aunque no es tan flexible como el método TypeOf, el método de instancia de la instancia de TypeOF devuelve "Objeto".

Uso general de la instancia del operador:

En términos generales, usar instanciaf es determinar si una instancia pertenece a un determinado tipo. Por ejemplo:

Listado 2. Uso general de instancia de

 // Determinar si FOO es una instancia de la función de clase FOO Foo () {} var foo = new foo (); console.log (foo instanciaf foo) // verdadero

Además, un punto más pesado es que la instancia de se puede usar en las relaciones de herencia para determinar si una instancia pertenece a su tipo principal. Por ejemplo:

Listado 3. Uso de instancia en las relaciones de herencia

 // Determinar si FOO es una instancia de la clase FOO y si es una instancia de su función de tipo principal aoo () {} function foo () {} foo.prototype = new aoo (); // JavaScript Prototype Heritance var foo = new foo (); console.log (foo instanceof foo) // true console.log (foo instanceof aoo) // true

En el código anterior, se juzga la clase principal en una capa de relación de herencia. En la relación de herencia de múltiples capas, la instancia del operador también es aplicable.

¿Realmente entiendes la instancia del operador?

Después de leer el ejemplo de código anterior, ¿cree que la instancia del operador es muy simple? Echemos un vistazo a un uso complicado.

Listado 4. Instancia de uso complejo

 console.log(Object instanceof Object);//true console.log(Function instanceof Function);//true console.log(Number instanceof Number);//false console.log(String instanceof String);//false console.log(Function instanceof Object);//true console.log(Foo instanceof Function);//true console.log(Foo instanceof Foo);//false

¿Estás confundido nuevamente después de leer el código anterior? ¿Por qué los objetos y la instancia de la función de sí mismos son igual verdaderos, mientras que otras instancias de sí mismos no son iguales? ¿Cómo explicarlo? Para comprender fundamentalmente el misterio de instancia, debemos comenzar desde dos aspectos: 1. Cómo definir este operador en la especificación del idioma. 2. Mecanismo de herencia prototipo de JavaScript.

Listado 5. JavaScript Instance del código del operador

 función instance_of (l, r) {// l representa la expresión izquierda, r representa la expresión correcta var o = r.prototype; // Tome el prototipo de visualización de r l = l .__ proto __; // Tome el prototipo implícito de l while (true) {if (l === null) return false; if (o === l) // Aquí está el punto: cuando o es estrictamente igual a L, devuelve verdadero; L = l .__ proto__; }}

Listado 6. Objeto instancia de objeto

 // En aras de la conveniencia de la expresión, primero distinga entre la expresión izquierda y la expresión derecha objeto = objeto, objectr = objeto; // lo siguiente es deducir gradualmente o = object.protype = object.protype l = object .__ proto__ = function.prototype // El primer juicio es o! = L // bucle para encontrar si l todavía tiene __proto__ l = function.prototype .__ proto__ = objeto

Listado 7. Función Instance de función

 // En aras de la conveniencia de la expresión, primero distinga entre la expresión izquierda y la expresión derecha functionL = function, functionR = function; // lo siguiente es deducir gradualmente o = functionr.prototype = function.prototype l = functionl .__ proto__ = function.prototype // El primer juicio o == l // return tree

Listado 8. Foo instancia de foo

 // En aras de la conveniencia de la expresión, primero distinga entre la expresión izquierda y la expresión derecha Fool = foo, foor = foo; // lo siguiente es deducir gradualmente de acuerdo con las especificaciones o = foor.prototype = foo.prototype l = fool .__ proto__ = function.prototype // El primer juicio es o! = L // El primer juicio es o! = L // el ciclo es encontrar si L/ __proto__ l = funct.pototype .__ proto__ = objeto.prototipo // el ciclo es encontrar __proto__ l = function.prototype .__ proto__ = objeto. Objeto. es encontrar si L todavía tiene __proto__ l = objeto.prototype .__ proto__ = null // El tercer juicio l == null // return false

Analice brevemente la aplicación de instancia en el mecanismo de herencia del dojo

En JavaScript, no hay concepto de herencia múltiple, al igual que Java. Sin embargo, al declarar clases en Dojo, se permite la herencia de múltiples clases. Tomemos a Dojo 1.6.1 como ejemplo.

Listado 9. Herencia múltiple en Dojo

 dojo.Declare ("aoo", nulo, {}); 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.isinstanceOf (boo)); // true console.log (foo.isinstanceOf (boo)); // verdadero verdadero

En el ejemplo anterior, Foo hereda de AOO y BOO, pero cuando se usa el operador de instancia para verificar si FOO es una instancia de BOO, devuelve FALSO. De hecho, dentro de Dojo, Foo todavía hereda solo desde AOO, y usa el mecanismo de mezcla para copiar los métodos y propiedades en la clase BOO a Foo. Por lo tanto, cuando la instancia del operador se usa para verificar si se trata de una instancia de BOO, se devolverá False. Entonces, Dojo agrega un nuevo método llamado ISInstanceOF para cada instancia de clase, y usa este método para verificar múltiples herencias.