JavaScript instanceof Operator Learning Tutorial _ Basics

Grammar

Object Instanceof Constructor

Parameters
Object
The object to be instrumented.
Constructor:
A constructor

Describe:
The instanceof operator is used to detect whether the Constructor.prototype exists on the prototype chain of parameter object.

Define constructor function function
C () {} 
function D () {} 

var o = new C ();

True because Object.getprototypeof (o) = = = C.prototype
o instanceof C; 

False because D.prototype is not on the prototype chain o
instanceof D; 

o instanceof Object; True because Object.prototype.isPrototypeOf (o) returns true
c.prototype instanceof Object//True, ditto

c.prototype = {} ;
var O2 = new C ();

O2 instanceof C; True

o instanceof C;//False,c.prototype points to an empty object that is not on the prototype chain of O.

D.prototype = new C (); Inherit
var O3 = new D ();
O3 instanceof D; True
O3 instanceof C;//True

It should be noted that if the expression obj instanceof Foo returns True, it does not mean that the expression will return to Ture forever, Because the value of the Foo.prototype property is likely to change, the value after the change is likely to not exist on the prototype chain of obj, when the value of the original expression becomes false. In another case, the value of the original expression will also change, that is, to change the prototype chain of object obj, although in the current ES specification, we can only read the object's prototype and not change it, but with the help of non-standard __proto__ magic attributes, can be achieved. For example, after executing obj.__proto__ = {}, obj instanceof Foo returns false.

Instanceof and multiple global objects (interaction between multiple frame or multiple windows)

In the browser, our script may need to interact with multiple windows. Multiple windows imply multiple global environments, and different global environments have different global objects that have different built-in type constructors. This may cause some problems. For example, an expression [] instanceof window.frames[0]. Array returns false because Array.prototype!== window.frames[0]. Array.prototype, so you must use Array.isarray (myobj) or Object.prototype.toString.call (myobj) = = "[Object Array]" To determine whether MyObj is an array.

Example
the general use of instanceof is to determine whether a is a B-type:

Console.log (True instanceof Boolean); False 
Console.log (new number (1) instanceof number);//True

Instanceof can also determine the parent type:

function Father () {}
function child () {}
Child.prototype = new Father ();
var a = new Child ();
Console.log (a instanceof child); True
Console.log (a instanceof Father);//True

The child constructor inherits from father, and instance A is no doubt constructed by the child, but why is it also an instance of Father? In fact, the kernel of the instanceof operator can be simply described in the following code:

function Check (A, b) {while
 (a.__proto__) {
  if (a.__proto__ = = B.prototype) return
   true;
  A = a.__proto__;
 }
 return false;
}

function Foo () {}
Console.log (object instanceof Object = = Check (object, object);//True 
Console.log ( function instanceof function = = Check (function, function)); True 
console.log (number instanceof number = = Check (number, number));//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)); True 
console.log (foo instanceof foo = = Check (foo, foo));//True

Simply put, if a is an instance of B, then a must be able to use the methods and attributes defined in the prototype of B, then the code representation is the same object in the prototype chain of a, which has the B.prototype value, and then it follows a layer of the prototype chain of a.

It is also noteworthy that String number Boolean and function are functions, and functions are unified by function constructs, so they, like any simple function, can use the stereotype properties on function:

Function.prototype.a = ten;
Console.log (STRING.A); 10

Finally, let's talk about the first two questions.

 To facilitate presentation, first distinguish between left and right expressions
 functionl = function, Functionr = function; 
 Below according to the specification step-by-Step deduction
 O = Functionr.prototype = Function.prototype 
 L = functionl.__proto__ = Function.prototype 
 // First judgment
 O = = L 
 //return TRUE//

to facilitate presentation, first differentiate between left and right expressions
 Stringl = string, Stringr = string; 
 Below according to the specification step-by-Step deduction
 O = Stringr.prototype = String.prototype 
 L = stringl.__proto__ = Function.prototype 
 // First Judge
 O!= L
 //loops find again l 
 = __proto__ L = string.prototype.__proto__ = Object.prototype 
 //second judgment 
   o!= L 
 //re-loop find l 
 = __proto__ L = string.prototype.__proto__ = null 
 //Third judgment
 L = = null 
 // return False