判断某种条件是否成立的函数集合

~ function(root) {
    var previousUtils = root.utils;
    var utils = {};
    var version = '0.0.1';
    var slice = Array.prototype.slice;
    var toString = Object.prototype.toString;
    var hasOwnProperty = Object.prototype.hasOwnProperty;
    var TypeMap = ['Error','Date','Function', 'Array', 'Object', 'Arguments', 'String', 'Null', 'Number', 'Boolean', 'Undefined'];
    for (var index = 0, len = TypeMap.length; index < len; index++) {
        var currentType = TypeMap[index];
        utils['is' + currentType] = (function(type) {
            return function() {
                var args = slice.call(arguments);
                var len = args.length;
                if (len === 0) {
                    return;
                } else if (len === 1) {
                    return toString.call(arguments[0]) === '[object ' + type + ']';
                } else {
                    for (var index = 0; index < len; index++) {
                        if (toString.call(args[index]) !== '[object ' + type + ']') {
                            return false;
                        }
                    }
                    return true;
                }

            }
        })(currentType)
    }



    utils.noConflict = function() {
        root.utils = previousUtils;
        return this;
    };

    utils.isInteger = Number.isInteger || function(digit) {
        return digit === (digit >> 0);
    }

    utils.isFloat = function(digit) {
        return /^\d+.\d+$/.test(digit);
    }

    utils.isEmpty = function(str) {
        return /^\s*$/.test(str);
    }

    utils.isFlase = function(variable) {
        switch(variable) {
            case '':
            case false:
            case 0:
            case undefined:
            case null: return true;
        }
        return false;
    }

    utils.isTrue = function(variable) {
        return !this.isFlase(variable);
    }

    utils.isIp = function(str) {
        return /^(([0-9]|[1-9][0-9]|1[0-9][0-9]|25[0-5]|2[0-4][0-9])\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|25[0-5]|2[0-4][0-9])$/.test(str)
    }

    utils.isPrecision = function(str,from,to) {
        from = +from;
        to = to ? ','+ to : '';
        var regexp = new RegExp(from ? '^\\d+\\.\\d{'+ from + to + '}$': '^\\d+$');
        return regexp.test(str);
    }

    utils.isBeginWith = function(sourceStr,substr) {
        sourceStr = String(sourceStr);
        substr = String(substr);
        if (sourceStr.length < substr.length) {
            return false;
        }
        var len = substr.length;
        var position = 0;
        for(; position < len; position++) {
            if (sourceStr[position] !== substr[position]) {
                return false;
            }
        }
        return true;
    }

    utils.isEndWith = function(sourceStr,substr) {
        sourceStr = String(sourceStr);
        substr = String(substr);
        if (sourceStr.length < substr.length) {
            return false;
        }
        var sourceStrLen = sourceStr.length;
        var substrLen = substr.length;
        var offset = sourceStrLen - substrLen;
        var position = 0;
        for(; position < substrLen; position++) {
            if (sourceStr[position+offset] !== substr[position]) {
                return false;
            }
        }
        return true;
    }

    utils.isAscii = function(variable,Case) {
        var regexp;
        if (Case === undefined) {
            regexp = /^[a-z]+$/i;
        } else if (Case === false){
            regexp = /^[a-z]+$/;
        } else if (Case === true){
            regexp = /^[A-Z]+$/;
        }
        return regexp.test(variable);
    }

    utils.isEqual = function(source,dest) {

        if (this.isArray(source,dest)) {
            if (!this.isEqual(source.length,dest.length)) {
                return false;
            }
            var len = source.length;
            for (var index = 0;index < len; index++) {
                if (!this.isEqual(source[index],dest[index])) {
                        return false;
                }
            }
            return true;
        }
        else if (this.isObject(source,dest)) {
            var sourceLen = Object.keys(source).length;
            var destLen = Object.keys(dest).length;
            if (!this.isEqual(sourceLen, destLen)) {
                return false;
            }
            for (var key in source) {
                if (!hasOwnProperty.call(source,key)) {
                    continue
                }
                else if(!utils.isEqual(source[key],dest[key])) {
                    return false;
                }
            }
            return true;
        }
        else {
            return source === dest;
        }
    }

    utils.flatten =function(arg,overwrite) {
        if (utils.isArray(arg)) {
            return utils.flattenArray(arg);
        }
        else if(utils.isObject(arg)){
            return utils.flattenObject(arg,overwrite);
        } else {
            return [arg];
        }
    }

    utils.flattenArray = function(arr) {
        var result = [];
        var len = arr.length;
        var index = 0;
        var position = 0;
        for (;index<len;index++) {
            var value = arr[index];
            if (utils.isArray(value)) {
                var tmp = utils.flattenArray(value);
                var _len = tmp.length;
                var _index = 0;
                while (_index<_len) {
                    result[position++] = tmp[_index++];
                }
            }
            else{
                result[position++] = value;//utils.isObject(value) ? JSON.stringify(value) : value;
            }
        }
        return result;
    }

    utils.flattenObject = function(obj, overwrite) { //键值越前越深就可能会被后面的覆盖
        if (!utils.isObject(obj)) {
            return;
        }
        var keys = Object.keys(obj);
        var len = keys.length;
        var result = {};
        for (var index = 0; index < len; index++) {
            var value = obj[keys[index]];
            if (utils.isObject(value)) {
                var ret = utils.flatten(value, overwrite);
                var _keys = Object.keys(ret);
                var _len = _keys.length;
                for (var _index = 0; _index < _len; _index++) {
                    var _key = _keys[_index];
                    (result[_key] && !overwrite) || (result[_key] = ret[_key]);
                }
            } else {
                (result[keys[index]] && !overwrite) || (result[keys[index]] = value);
            }
        }
        return result;
    }

    utils.ArrayToObject = function(arr) {
        arr = utils.flatten(arr);
        var value;
        var result = {};
        while(value = arr.shift()) {
            value = utils.isObject(value) ? JSON.stringify(value) : value;
            result[value] = true;
        }   
        return result;
    }
    utils.isInclude = function(source,keys) {
        source = utils.flatten(source);
        keys = utils.flatten(keys);
        var index = 0;
        var result;
        if (this.isObject(source)) {
            for (;index < keys.length; index++) {
                if (!(keys[i] in source)) {
                    return false
                }
            }
            return true;
        } else if (this.isArray(source)){
            result = utils.ArrayToObject(source);
            for (;index < keys.length; index++) {
                var tmp = utils.isObject(keys[index]) ? JSON.stringify(keys[index]) : keys[index];
                if (!(tmp in result)) {
                    return false
                }
            }
            return true;
        } else {
            return source === keys;
        }
    }
    self._utils = utils;
}(self)