Instancia de JavaScript Tutorial de aprendizaje del operador

gramática

 instancia de objeto de constructor

parámetro

objeto:

El objeto a ser detectado.

constructor:

Un constructor

describir:

La instancia del operador se utiliza para detectar si el constructor.prototype existe en la cadena prototipo del objeto de parámetro.

 // Defina la función del constructor c () {} función d () {} var o = new C (); // true, porque object.getPrototypeOf (o) === C.PrototypeO instanciaf c; // Falso, porque D.Prototipo no está en la cadena prototipo de O instancia de D; o instancia de objeto; // Verdadero, porque object.prototype.IsprototypeOf (O) devuelve trueC.protype instanceOf object // true, igual que el anterior c.prototype = {}; var o2 = new c (); o2 instanciaf c; // instancia verdadera de c; // falso, c.prototype apunta a un objeto vacío, que no está en la cadena prototipo de O.D.Prototype = new C (); // heredar var o3 = new d (); o3 instancia de d; // instancia de verdado3 c; // verdadero

Cabe señalar que si la expresión OBJ instancia de Foo regresa verdadera, no significa que la expresión devolverá la tura para siempre, porque el valor de la propiedad Foo.prototype puede cambiar, y el valor cambiado puede no existir en la cadena de prototipos OBJ, y el valor de la expresión original se volverá falso. En otro caso, el valor de la expresión original también cambiará, que es el caso en el que se cambia la cadena prototipo del objeto OBJ. Aunque en la especificación ES actual, solo podemos leer el prototipo del objeto y no podemos cambiarlo, se puede lograr con la ayuda del atributo mágico __proto__ no estándar. Por ejemplo, después de ejecutar obj .__ proto__ = {}, la instancia de obj de foo devolverá falso.

instanciaf y objetos multiglóbicos (interacción entre múltiples marcos o ventanas múltiples)

En un navegador, nuestros scripts pueden necesitar interactuar entre múltiples ventanas. Múltiples ventanas significan múltiples entornos globales, y diferentes entornos globales tienen diferentes objetos globales, con diferentes constructores de tipo incorporado. Esto puede causar algunos problemas. Por ejemplo, la expresión [] instancia de Window.frames [0] .Array devolverá falso porque array.prototype! == window.frames [0] .Array.prototype, por lo que debe usar Array.IsArray (myobj) o objeto.prototype.ToString.call (myobj) === "[Object Array]" para determinar si myobj es un myobj es un matriz.

Ejemplo

El uso general de instanciaf es determinar si A es del tipo B:

 console.log (verdadera instancia de boolean); // false console.log (nuevo número (1) instancia de número); // verdadero

InstanceOf también puede determinar el tipo principal:

 function father () {} function child () {} child.prototype = new Father (); var a = new Child (); console.log (una instancia de child); // Trueconsole.log (una instancia de padre); // verdadero

El constructor infantil hereda del padre. La instancia A es indudablemente construida por el niño, pero ¿por qué también es una instancia de padre? De hecho, el núcleo de la instancia de operador se puede describir simplemente con el siguiente código:

 Comprobación de funciones (a, b) {while (a .__ proto__) {if (a .__ proto__ === b.prototype) return true; a = a .__ proto__; } return false;} function foo () {} console.log (objeto instanceof object === check (objeto, objeto)); // true console.log (función instanciaf function === check (función, función)); // true console.log (número de instancia de número === check (número, número)); // 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, function)); // verdadero console.log (foo instanciaf foo === check (foo, foo)); // verdadero console.log (foo instanciaf foo === check (foo, foo)); // verdadero console.log (foo instanciaf foo === check (foo, foo)); // verdadero

En pocas palabras, si A es una instancia de B, entonces A definitivamente puede usar los métodos y propiedades definidas en el prototipo de B. Luego, en el código, significa que hay objetos con el mismo valor en una cadena prototipo con b.prototipo, por lo que simplemente siga una cadena prototipo de A para buscar capa por capa.

También vale la pena señalar que el número de cadena booleano y la función son funciones, y las funciones están construidas de manera uniforme a partir de la función. Son como cualquier función simple y pueden usar las propiedades prototipo en la función:

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

Finalmente, hablemos brevemente sobre las dos primeras preguntas.

 // En aras de la conveniencia de la expresión, primero distinga la expresión izquierda y la función de expresión derecha de función, functionR = function; // a continuación se deduce gradualmente de acuerdo con las especificaciones o = functionr.prototype = function.protype l = functionl .__ proto__ = function.prototype // primer juicio o == l // return verdadero // por el bien de la conveniencia de la expresión, primero distinga la expresión izquierda y la expresión correcta Stringl = String, stringr = string; // a continuación se deduce gradualmente de acuerdo con las especificaciones o = StringR.Prototype = String.Prototype l = Stringl .__ proto__ = function.prototype // Los jueces de la primera vez o! = L // loops nuevamente para encontrar si L todavía tiene __proto__ l = String.prototype .__ proto__ = objeto.prototype // la segunda vez a juzgar o! = L // loops de nuevo para encontrar de nuevo. __proto__ l = string.prototype .__ proto__ = null // La tercera vez jueces l == null // return false