JAVAscript—[判断对象类型的方法]

一、Object.prototype.toString.call(obj) 推荐（最精准的方式）

console.log(Object.prototype.toString.call("jerry"));//[object String]
console.log(Object.prototype.toString.call(12));//[object Number]
console.log(Object.prototype.toString.call(true));//[object Boolean]
console.log(Object.prototype.toString.call(undefined));//[object Undefined]
console.log(Object.prototype.toString.call(null));//[object Null]
console.log(Object.prototype.toString.call({name: "jerry"}));//[object Object]
console.log(Object.prototype.toString.call(function(){}));//[object Function]
console.log(Object.prototype.toString.call([]));//[object Array]
console.log(Object.prototype.toString.call(new Date));//[object Date]
console.log(Object.prototype.toString.call(/\d/));//[object RegExp]
function Person(){};
console.log(Object.prototype.toString.call(new Person));//[object Object]

优点：检测出所有的类型
缺点：IE6下，undefined和null均为Object

二、typeof运算符

typeof算是最常见的了，使用它会返回一个字符串，适合函数对象和基本类型（js中的基本类型：number、string、boolean、null、undefined、object［对象］）的判断。

<script type="text/javascript">
console.log(typeof 1);   //number
console.log(typeof "str");  //string
console.log(typeof false);  //boolean
console.log(typeof null);   //object
console.log(typeof undefined);  //undefined
console.log(typeof new Object());  //object
console.log(typeof new Array());  //object
console.log(typeof NaN);  //number
console.log(typeof [1,2,3]);  //object
console.log(typeof function(){});  //function
</script>

优点：使用简单
缺点：
(1)对于数组、函数、对象来说，其关系错综复杂，使用 typeof 都会统一返回 “object” 字符串
(2)null也会返回object
(3)对NaN返回是number

三、instanceof（基于原型链）（obj instanceof Object）

var str = 'hello';
alert(str instanceof String);//false
var bool = true;
alert(bool instanceof Boolean);//false
var num = 123;
alert(num instanceof Number);//false
var nul = null;
alert(nul instanceof Object);//false
var und = undefined;
alert(und instanceof Object);//false
var oDate = new Date();
alert(oDate instanceof Date);//true
var json = {};
alert(json instanceof Object);//true
var arr = [];
alert(arr instanceof Array);//true
var reg = /a/;
alert(reg instanceof RegExp);//true
var fun = function(){};
alert(fun instanceof Function);//true
var error = new Error();
alert(error instanceof Error);//true

优点：能检测出引用类型
缺点：不能检测出基本类型，且不能跨iframe

四、constructor（Object.constructor()）

// 字符串：String()
var str = "张三";
alert(str.constructor); // function String() { [native code] }
alert(str.constructor === String); // true
 
// 数组：Array()
var arr = [1, 2, 3];
alert(arr.constructor); // function Array() { [native code] }
alert(arr.constructor === Array); // true
 
// 数字：Number()
var num = 5;
alert(num.constructor); // function Number() { [native code] }
alert(num.constructor === Number); // true
 
// 自定义对象：Person()
function Person(){
    this.name = "CodePlayer";
}
var p = new Person();
alert(p.constructor); // function Person(){ this.name = "CodePlayer"; }
alert(p.constructor === Person); // true
 
// JSON对象：Object()
var o = { "name" : "张三"};
alert(o.constructor); // function Object() { [native code] }
alert(o.constructor === Object); // true
 
// 自定义函数：Function()
function foo(){
    alert("CodePlayer");
}
alert(foo.constructor); // function Function() { [native code] }
alert(foo.constructor === Function); // true
 
// 函数的原型：bar()
function bar(){
    alert("CodePlayer");
}
alert(bar.prototype.constructor); // function bar(){ alert("CodePlayer"); }
alert(bar.prototype.constructor === bar); // true

优点：基本能检测所有的类型（除了null和undefined）
缺点：constructor易被修改，也不能跨iframe

五、Array.isArray判断某个值是否为数组，返回布尔类型

// 下面的函数调用都返回 true
console.log(Array.isArray([]));
console.log(Array.isArray([1]));
console.log(Array.isArray(new Array()));
// 下面的函数调用都返回 false
console.log(Array.isArray());
console.log(Array.isArray({}));
console.log(Array.isArray(null));
console.log(Array.isArray(undefined));
console.log(Array.isArray(17));
console.log(Array.isArray('Array'));
console.log(Array.isArray(true));
console.log(Array.isArray(false));

优点：Array.isArray是ES 5.1推出的，不支持IE6~8，所以在使用的时候也应注意兼容问题。
缺点：只能判别数组，如果传进来的object是数组，返回true，如果不是数组，则返回false。