JavaScript 中typeof 和 instanceof 常用来推断一个变量是不是为空，或许是什么范例的。但它们之间照样有区分的：

typeof

typeof 是一个一元运算，放在一个运算数之前，运算数可所以恣意范例。

它返回值是一个字符串，该字符串申明运算数的范例。（typeof 运算符返回一个用来示意表达式的数据范例的字符串。 ）

typeof实在就是推断参数是什么范例的实例，就一个参数

typeof 平常只能返回以下几个效果：”number“、”string“、”boolean“、”object“、”function” 和 “undefined“。

运算数为数字 typeof(x) = "number"

字符串 typeof(x) = "string"

布尔值 typeof(x) = "boolean"

对象,数组和null typeof(x) = "object"

函数 typeof(x) = "function"

console.log(typeof (123));//typeof(123)返回"number" 
console.log(typeof ("123"));//typeof("123")返回"string"
var param1 = "string";
var param2 = new Object();
var param3 = 10;
console.log(typeof(param1)+"\n"+typeof(param2)+"\n"+typeof(param3)); 
　　　　　//　string object  number

我们能够运用 typeof 来猎取一个变量是不是存在，如 if(typeof a!="undefined"){alert("ok")}，而不要去运用 if(a) 由于假如 a 不存在（未声明）则会失足，关于 Array,Null 等特别对象运用 typeof 一概返回 object，这正是 typeof 的局限性。

常常会在js里用到数组,比方 多个名字雷同的input, 如果动态天生的, 提交时就须要推断其是不是是数组.

　　if(document.mylist.length != "undefined" ) {} //这个用法有误.

    准确的是 `if( typeof(document.mylist.length) != "undefined" ) {}` 

     或 `if( !isNaN(document.mylist.length) ) {}` 

typeof的运算数未定义,返回的就是 “undefined“.

在 JavaScript 中，推断一个变量的范例试试会用 typeof 运算符，在运用 typeof 运算符时采纳援用范例存储值会涌现一个题目，不管援用的是什么范例的对象，它都返回 “object”。这就须要用到instanceof来检测某个对象是不是是另一个对象的实例。

instanceof

instanceof 运算符用来测试一个对象在其原型链中是不是存在一个组织函数的 prototype 属性。

语法：object instanceof constructor
参数：object（要检测的对象.）constructor（某个组织函数）
形貌：instanceof 运算符用来检测 constructor.prototype 是不是存在于参数 object 的原型链上。

instance：实例,例子

a instanceof b?alert("true"):alert("false"); //a是b的实例？真:假

instanceof 用于推断一个变量是不是某个对象的实例，

如 :var a=new Array();

alert(a instanceof Array); // true，

同时 alert(a instanceof Object) //也会返回 true;

这是由于 Array 是 object 的子类。



再如：function test(){};

var a=new test();

alert(a instanceof test) 会返回true

alert(a==b);  //flase

案例：

别的，更重的一点是 `instanceof` 能够在继续关联中用来推断一个实例是不是属于它的父范例。

比方：

function Foo(){} 
Foo.prototype = new Aoo();//JavaScript 原型继续 
var foo = new Foo(); 
console.log(foo instanceof Foo)//true 
console.log(foo instanceof Aoo)//true

上面的代码中是推断了一层继续关联中的父类，在多层继续关联中，instanceof 运算符一样实用。


又如：

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

// 定义组织函数
function C(){} 
function D(){} 

var o = new C();

// true，由于 Object.getPrototypeOf(o) === C.prototype
o instanceof C; 

// false，由于 D.prototype不在o的原型链上
o instanceof D; 

o instanceof Object; // true,由于Object.prototype.isPrototypeOf(o)返回true
C.prototype instanceof Object // true,同上

C.prototype = {};
var o2 = new C();

o2 instanceof C; // true

o instanceof C; // false,C.prototype指向了一个空对象,这个空对象不在o的原型链上.

D.prototype = new C(); // 继续
var o3 = new D();
o3 instanceof D; // true
o3 instanceof C; // true

谈到 instanceof 我们要多插进去一个题目，就是 function 的 arguments，我们人人或许都以为 arguments 是一个 Array，但假如运用 instaceof 去测试会发明 arguments 不是一个 Array 对象，只管看起来很像。

别的：

测试 var a=new Array();if (a instanceof Object) alert(‘Y’);else alert(‘N’);

得’Y’

但 if (window instanceof Object) alert(‘Y’);else alert(‘N’);

得’N’

所以，这里的 instanceof 测试的 object 是指 js 语法中的 object，不是指 dom 模子对象。

运用 typeof 会有些区分

alert(typeof(window)) 会得 object

须要注重的是，假如表达式 obj instanceof Foo 返回true，则并不意味着该表达式会永久返回ture，由于Foo.prototype属性的值有能够会转变，转变以后的值很有能够不存在于obj的原型链上，这时候原表达式的值就会成为false。别的一种状况下，原表达式的值也会转变，就是转变对象obj的原型链的状况，虽然在现在的ES范例中，我们只能读取对象的原型而不能转变它，但借助于非标准的__proto__魔法属性，是能够完成的。比方实行obj.__proto__ = {}以后，obj instanceof Foo就会返回false了。

例子: 表明String对象和Date对象都属于Object范例
下面的代码运用了instanceof来证实：String和Date对象同时也属于Object范例。

例子: 表明String对象和Date对象都属于Object范例

下面的代码运用了instanceof来证实：String和Date对象同时也属于Object范例。
var simpleStr = "This is a simple string"; 
var myString  = new String();
var newStr    = new String("String created with constructor");
var myDate    = new Date();
var myObj     = {};

simpleStr instanceof String; // returns false, 搜检原型链会找到 undefined
myString  instanceof String; // returns true
newStr    instanceof String; // returns true
myString  instanceof Object; // returns true

myObj instanceof Object;    // returns true, despite an undefined prototype
({})  instanceof Object;    // returns true, 同上

myString instanceof Date;   // returns false

myDate instanceof Date;     // returns true
myDate instanceof Object;   // returns true
myDate instanceof String;   // returns false