[JS]JS中的instanceof运算符

typeof返回一个表达式的数据类型的字符串，返回结果为js基本的数据类型，包括number,boolean,string,object,undefined,function.语法为typeof(data) 或 typeof data
instanceof则为判断一个对象是否为某一数据类型，或一个变量是否为一个对象的实例;返回boolean类型.
instanceof运算符用来判断一个构造函数的prototype属性所指向的对象是否存在于另外一个要检测对象的原型链上.
object instanceof constructor
参数：object:要检测的对象；constructor:某个构造函数
描述：instanceof 运算符用来检测 constructor.prototype 是否存在于参数 object 的原型链上。

判断类的prototype对象是否存在于实例对象的原型链上。是则返回true。
例如：obj instanceof Fn
1，objProto = obj.__proto__ 。(__proto__指对象 内部隐式的[[Prototype]] ，在FF、chrome下可用__proto__访问，其他浏览器不一定能访问)
2，判断Fn.prototype ===  objProto , 是则返回true,否则
3，objProto === objProto .__proto__,如果objProto 不为null ,跳到2

原理

做个函数模拟A instanceof B：

function _instanceof(A, B) {
    var O = B.prototype;// 取B的显示原型
    A = A.__proto__;// 取A的隐式原型
    while (true) {
        //Object.prototype.__proto__ === null
        if (A === null)
            return false;
        if (O === A)// 这里重点：当 O 严格等于 A 时，返回 true
            return true;
        A = A.__proto__;
    }
}

实例

function Cat(){}
Cat.prototype = {}
function Dog(){}
Dog.prototype = {}

var dog1 = new Dog();
console.log(dog1 instanceof Dog);//true
console.log(dog1 instanceof Object);//true
 
Dog.prototype = Cat.prototype;
console.log(dog1 instanceof Dog);//false
console.log(dog1 instanceof Cat);//false
console.log(dog1 instanceof Object);//true;
 
var  dog2= new Dog();
console.log(dog2 instanceof Dog);//true
console.log(dog2 instanceof Cat);//true
console.log(dog2 instanceof Object);//true

Dog.prototype = null;
var dog3 = new Dog();
console.log(dog3 instanceof Cat);//false
console.log(dog3 instanceof Object);//true
console.log(dog3 instanceof Dog);//error
// 通常来讲，使用 instanceof 就是判断一个实例是否属于某种类型。            
//另外，更重的一点是 instanceof 可以在继承关系中用来判断一个实例是否属于它的父类型

1.instanceof的普通的用法

obj instanceof Object 检测Object.prototype是否存在于参数obj的原型链上。

Person的原型在p的原型链中

function Person(){};
var p =new Person();
console.log(p instanceof Person);//true

2.继承中判断实例是否属于它的父类

Student和Person都在s的原型链中

function Person(){};
function Student(){};
var p = new Person();
Student.prototype = p;//继承原型
var s=new Student();
console.log(s instanceof Student);//true
console.log(s instanceof Person);//true

function Ben_parent() {}
function Ben_son() {}
//Ben_son.prototype = new Ben_parent();//原型继承
Ben_son.prototype = Ben_parent;//

var ben_son = new Ben_son();
console.log(ben_son instanceof Ben_son);//true
console.log(ben_son instanceof Ben_parent);//false
console.log(ben_son instanceof Function);//true
console.log(ben_son instanceof Object);//true

3. instanceof 复杂用法

console.log(Number instanceof Number);//false
console.log(String instanceof String);//false
console.log(String instanceof Function);//true
console.log(String instanceof Object);//true     
console.log(Function instanceof Object);//true
console.log(Function instanceof Function);//true  
console.log(Object instanceof Function);//true
console.log(Object instanceof Object);//true
console.log(Object.prototype instanceof Function);//false
console.log(Function.prototype instanceof Object);//true
console.log(Object.__proto__ instanceof Function);//false
console.log(Function.__proto__ instanceof Object);//true  //原型链的形成是真正是靠__proto__ 而非prototype
//Object,Function是JS自带的函数对象。还有Number、Boolean、String、Array、RegExp、Error、Date,既然是函数对象，所有他们都继承Function，Object这个两个对象。
//从后8条中可以看出，Function继承Object。
//看看能不能写成原型链