javascript中类型判断一般见解，更新一个工具库

javascript类型判断

在js中，核心给我们提供了typeof方法来判断一个变量的类型，返回的是字符串型，但是对于数组，或者对象和函数，我们就没有什么办法了。但是我们可以引用对象也就是Object的toString方法来实现对类型的判断，例：

例子

var arr = [];
    console.log(typeof arr);//object
    console.log(Object.prototype.toString.call(arr));//[object Array]

Ps:对于数组而言，arr的typeof后的类型是Object,这并不是我们想要的，而用Object的toString方法来说就很明确的可以判断出是什么类型的了，但是[object Array]这种形式，我们不好在程序里面来处理，所以本人在日常工作中封装了一个简单的方法来返回出类型的字符串，例：

例子

function getType(ele){
    if(!ele)return undefined;
    var type = Object.prototype.toString.call(ele),
    reg = /\[object (.*)\]/,
    arr = reg.exec(type);
    return arr[1];
}

Ps:这样就返回了一个字符串形式的类型，可以返回String,Number,Bloolen,Function,Array,Object，undefined,Null这几个字符串，那么在程序中就好判断了。

---

更新一个类型判断的插件

代码

var Type = (function() {
    var Type = function() {
        if (!this instanceof Type) {
            return new Type();
        }
    };

    var menth = {
        version: 'v1.0',
        getType: function(ele) {
            if (window == document && document != window) {
                return 'window';
            } else if (ele.nodeType === 9) {
                return 'document';
            } else if (ele.callee) {
                return 'arguments';
            } else if (isFinite(ele.length) && ele.item) {
                return 'NodeList';
            } else {
                var type = Object.prototype.toString.call(ele),
                    reg = /\[object (.*)\]/,
                    arr = reg.exec(type);
                return arr[1];
            }
        },
        isArray : function(ele){
            return (this.getType(ele) === 'Array') ? true : false;
        },
        isFunction : function(ele){
            return (this.getType(ele) === 'Function') ? true : false;
        },
        isObject : function(ele){
            return (this.getType(ele) === 'Object') ? true : false;
        },
        isString : function(ele){
            return (this.getType(ele) === 'String') ? true : false;
        },
        isNumber : function(ele){
            return (this.getType(ele) === 'Number') ? true : false;
        },
        isBoolen : function(ele){
            return (this.getType(ele) === 'Boolean') ? true : false;
        },
        isUndefined : function(ele){
            return (this.getType(ele) === 'Undefined') ? true : false;
        },
        isNull : function(ele){
            return (this.getType(ele) === 'Null') ? true : false;
        }
    }
    Type = extendDeep(Type.prototype,menth);



    // 扩展工具
    function extendDeep() {
            var i,
                target = arguments[0] || {},
                astr = '[object Array]',
                toStr = Object.prototype.toString,
                yArr = Array.prototype.slice.call(arguments, 1);
            for (i = 0, len = yArr.length; i < len; i++) {
                var temp = yArr[i];
                for (var j in temp) {
                    if (target.hasOwnProperty(j) && (target[i] === temp[i])) {
                        continue;
                    }
                    if (temp.hasOwnProperty(j)) {
                        if (typeof temp[j] === 'object') {
                            target[j] = (toStr.call(temp[j] === astr)) ? [] : {};
                            extendDeep(target[j], temp[j]);
                        } else {
                            if (typeof temp[j] !== 'undefined') {
                                target[j] = temp[j];
                            }
                        }
                    }
                }
            }

            return target;
        }
console.log(Type)
    return Type;
})();