javascript中类型检查有很多方法，比如typeof、instanceof、constructor、Object.prototype.toString()四种方法，前三种方法都存在不能检测的类型，只有第四种属于万能的。<p>

typeof

typeof的缺陷在于不能检测Array、json、null、Date()、Error类型。

instanceof

instanceof相当于实例对象的检测，instanceof 方法要求开发者明确地确认对象为某特定类型。

例如：

var person=new Person();
console.log(person instanceof Person)

num instanceof Number;
str instanceof String;
bool instanceof Bollean;
.....

不能完全检测的是，instanceof会把null和undefined检测为object类型。

constructor

constructor是对象上的属性，指向构造函数。实例对象寻找属性的顺序，实例对象上没有实例属性或方法时，就先去原型链上找，因此实例属性也可使用constructor属性。这种方式存在的缺陷是，除了undefined和null，其他类型的变量均能使用constructor判断出类型。

Object.prototype.toString()

Object.prototype.toString.call(变量)输出的是一个字符串，字符串里有一个数组，第一个参数是Object，第二个参数就是这个变量的类型，直接匹配这个类型就行。下面是一个封装好的库，可以直接用呀。<p>

J.$package(function(J){

    var ots=Object.prototype.toString;

    var type={
        /**
         * 判断是否数组
         * 
         * @name isArray
         * @function
         * @memberOf J.type
         * @param {Object} o 判断对象
         * @return {boolean} 是否数组
         */   
        isArray : function(o){
            return o && (o.constructor === Array || ots.call(o) === "[object Array]");
        },
        /**
         * 判断是否Object
         * 
         * @name isObject 
         * @function
         * @memberOf J.type
         * @param {Object} o 判断对象
         * @return {boolean} 是否Object
         */   
        isObject : function(o) {
            return o && (o.constructor === Object || ots.call(o) === "[object Object]");
        },
        /**
         * 判断是否布尔类型
         * 
         * @name isBoolean 
         * @function
         * @memberOf J.type
         * @param {Object} o 判断对象
         * @return {boolean} 是否布尔类型
         */  
        isBoolean : function(o) {
            return (o === false || o) && (o.constructor === Boolean);
        },
        /**
         * 判断是否数值类型
         * 
         * @name isNumber
         * @function
         * @memberOf J.type
         * @param {Object} o 判断对象
         * @return {boolean} 是否数值类型
         */  
        isNumber : function(o) {
            return (o === 0 || o) && o.constructor === Number;
        },
        /**
         * 判断是否undefined
         * 
         * @name isUndefined
         * @function
         * @memberOf J.type
         * @param {Object} o 判断对象
         * @return {boolean} 是否undefined
         */ 
        isUndefined : function(o) {
               return typeof(o) === "undefined";
        },
        /**
         * 判断是否Null
         * 
         * @name isNull
         * @function
         * @memberOf J.type
         * @param {Object} o 判断对象
         * @return {boolean} 是否Null
         */ 
        isNull : function(o) {
               return o === null;
        },
       /**
         * 判断是否function
         * 
         * @name isFunction
         * @function
         * @memberOf J.type
         * @param {Object} o 判断对象
         * @return {boolean} 是否function
         */ 
        isFunction : function(o) {
               return o && (o.constructor === Function);
        },
       /**
         * 判断是否字符串
         * 
         * @name isString
         * @function
         * @memberOf J.type
         * @param {Object} o 判断对象
         * @return {boolean} 是否字符串
         */ 
        isString : function(o) {
            return (o === "" || o) && (o.constructor === String);
        }
    }
    J.type=type;
});