javascript学习笔记——如何判断对象的类型

    1.typeof

    typeof是我们在做类型判断时最常用的方法，他的优点就是简单、好记，缺点是不能很好的判断object、null、array、regexp和自定义对象。

    下面是我的测试代码：
    

var str='str';
var arr=['1','2'];
var num=1;
var bool=true;
var obj={name:'test'};
var nullObj=null;
var undefinedObj=undefined;
var reg=/reg/;

function fn(){
    alert('this is a function');
}

function User(name){
    this.name=name;
}
var user=new User('user');

console.log(typeof str);
console.log(typeof arr);
console.log(typeof num);
console.log(typeof bool);
console.log(typeof obj);
console.log(typeof nullObj);
console.log(typeof undefinedObj);
console.log(typeof reg);
console.log(typeof fn);
console.log(typeof user);

    output：string，object，number，boolean，object，object，undefined，object，function，object
    

    2.constructor

　　现在介绍一种不常使用的方法，对象构造器constructor。他的优点是支持大部分对象类型的判断，特别是对自定义对象的判断；缺点是不能在null和undefined上使用。

　　测试代码和之前的差不多，区别就是使用XXX.constructor代替了typeof，而且需要对结果进行处理才能得到类型。

var str='str';
var arr=['1','2'];
var num=1;
var bool=true;
var obj={name:'test'};
var nullObj=null;
var undefinedObj=undefined;
var reg=/reg/;
function fn(){
    alert('this is a function');
}
function User(name){
    this.name=name;
}
var user=new User('user');

console.log(str.constructor);
console.log(arr.constructor);
console.log(num.constructor);
console.log(bool.constructor);
console.log(obj.constructor);
console.log(reg.constructor);
console.log(fn.constructor);
console.log(user.constructor);

console.log(nullObj.constructor);
console.log(undefinedObj.constructor);

    output:
      function String() {[native code]}
    function Array() { [native code] }
    function Number() { [native code] }
    function Boolean() { [native code] }
    function Object() { [native code] }
    function RegExp() { [native code] }
    function Function() { [native code] }
    function User(name){ this.name=name; }
    后两句出错；
    

    3.Object.prototype.toString.call()

　　最后要介绍的是jquery中使用的方式，Object.prototype.toString.call()。同样需要对结果继续处理(slice(8,-1))，优点是支持绝大多数类型的判断，唯一的缺点是不支持自定义对象的判断。

　　测试代码如下：

var str='str';
var arr=['1','2'];
var num=1;
var bool=true;
var obj={name:'test'};
var nullObj=null;
var undefinedObj=undefined;
var reg=/reg/;
function fn(){
    alert('this is a function');
}
function User(name){
    this.name=name;
}
var user=new User('user');

var toString=Object.prototype.toString;

console.log(toString.call(str));
console.log(toString.call(arr));
console.log(toString.call(num));
console.log(toString.call(bool));
console.log(toString.call(obj));
console.log(toString.call(reg));
console.log(toString.call(fn));
console.log(toString.call(user));
console.log(toString.call(nullObj));
console.log(toString.call(undefinedObj));

    output:
    [object String]
    [object Array]
    [object Number]
    [object Boolean]
    [object Object]
    [object RegExp]
    [object Function]
    [object Object]
    [object null]
    [object Undefined]
    console.log(toString.call(user)); 的返回结果为：[object Object]，不能做进一步判断。

    通过上面的例子，大家一定对这三种方式有了更深刻的认识，熟悉他们的优缺点，然后可以根据自己的需要选择合适的方式。推荐使用Object.prototype.toString.call()方法，因为他能解决绝大部分情况的判断，在遇到返回值为[object Object]时，再使用constructor辅助判断，看是否是自定义对象。

信息来源：http://www.cnblogs.com/softlover/archive/2012/11/30/2795515.html