/*
此js作为 utility库 主要用于 类型判断
*/
Namespace.register("U.Ut");

//判断是否为数组
U.Ut.isArray = Array.isArray;

/**
* 判断字符串是否为Guid
*
* @param   {string} 需要判断的字符串
* @return  {boolean} 是否为guid
*/
U.Ut.isGuid = function (UST) {
    return U.MS.isGuid(UST);
}

/**
* 判断值是否等于formdate
*
* @param   {object} 需要判断的FormData
* @return  {boolean} 是否为FormData
*/
U.Ut.isFormData = function (obj) {
    return obj.toString() === "[object FormData]";
}

/**
* 判断是否为对象
*
* @param   {object} 判断对象是否为object对象
* @return  {boolean} 是否为FormData
*/
U.Ut.isObject = function (UDE) {
    return (typeof UDE == "object" && UDE !== null);
}

/**
* 是否参与for in循环的对象
*
* @param   {object} 判断是否允许参加在for循环里
* @return  {boolean} 允许for in
*/
U.Ut.IsFObj = function (UDE) {
    var i, _ = ["isArray", "isFunction", "isObject"]; //三种可参与for in的
    for (i = 0; i < _.length; i++) {
        if (U.M[_[i]](UDE)) {
            return _[i].substr(2);
        }
    }
    return false;
}

/**
* 判断数组是否可用
*
* @param   {array} 判断数组是否有值
* @return  {boolean} 是否为有值数组
*/
U.Ut.isArrayLike = function (UDE) {
    return UDE && UDE.length && UDE.length < Array.MAX_ARRAY_INDEX;
}

/**
* 判断是否为bool
*
* @param  {array} 判断数组是否有值
* @return  {boolean} 是否为boolean值
*/
U.Ut.isBoolean = function (UDE) {
    return typeof UDE === "boolean";
}

/**
* 判断是否为空
*
* @param  {object} 判断内容是否为空
* @return  {boolean} 是否为null
*/
U.Ut.isNull = function (UDE) {
    return UDE === null;
}

/**
* 判断是否为数字
*
* @param  {array} 判断数组是否有值
* @return  {boolean} 是否为number
*/
U.Ut.isNumber = function (UDE) {
    return typeof UDE == "number";
}

/**
* 判断是否为字符串数字
*
* @param  {array} 判断数组是否有值
* @return  {boolean} 是否为number
*/
U.Ut.isStringInt = function (UDE) {
    return U.Ut.isNumber(UDE) || U.MS.Num.test(UDE);
}

/**
* 判断是否为NaN
*
* @param  {array} 判断数组是否有值
* @return  {boolean} 是否为number
*/
U.Ut.isNaN = function (UDE) {
    typeof UDE == "NaN";
}

/**
* 判断是否是无限循环数字
*
* @param  {number} 判断数组是否有值
* @return  {boolean} 是否为number
*/
U.Ut.isFinite = function (UDE) {
    return !isNaN(parseFloat(UDE)) && isFinite(UDE);
}

/**
* 判断是否为字符串
*
* @param  {string} 判断的字符串
* @return  {boolean} 是否为字符串
*/
U.Ut.isString = function (str) {
    return typeof str == "string"
}

/**
* 判断是否为Undefined
*
* @param  {number} 判断数组是否有值
* @return  {boolean} 是否为number
*/
U.Ut.isUndefined = function (UDE) {
    return (UDE === void 0);
}

/**
* 判断是否为正则
*
* @param  {RegExp} 正则值
* @return  {boolean} 是否为RegExp
*/
U.Ut.isRegExp = function (UDE) {
    return U.Ut.isObject(UDE) && U.M.objectToString(UDE) == "[object RegExp]";
}

/**
* 判断是否为时间
*
* @param  {Date} 时间对象值
* @return  {boolean} 是否为Date
*/
U.Ut.isDate = function (UDE) {
    return U.Ut.isObject(UDE) && U.M.objectToString(UDE) == "[object Date]";
}

/**
* 判断是否为错误
*
* @param  {Error} 错误对象值
* @return  {boolean} 是否为错误类型
*/
U.Ut.isError = function (UDE) {
    return U.Ut.isObject(UDE) && U.M.objectToString(UDE) == "[object Error]";
}

/**
* 判断是否为函数类型
*
* @param  {function} 函数值
* @return  {boolean} 函数对象值
*/
U.Ut.isFunction = function (UDE) {
    return ((typeof UDE == "function" && UDE.prototype) || U.M.objectToString(UDE) == "[object Function]");
}

/**
* 判断是否为传参类
*
* @param  {object} 函数值
* @return  {boolean} 返回是否为Arguments对象
*/
U.Ut.isArguments = function (UDE) {
    return (typeof (UDE == "object") && _$(UDE).has("callee"));
}

/**
* 判断object是否是空对象
*
* @param  {object} 对象值
* @return  {boolean} 是否空对象
*/
U.Ut.isEmpty = function (UDE) {
    var i, _UTF = true;
    for (i in UDE) {
        if (UDE.hasOwnProperty(i)) { _UTF = false; break; }
    }
    return _UTF;
}

/**
* 判断是否为基础类型
*
* @param  {object} undefined function string number object
* @return  {boolean} 是否空对象
*/
U.Ut.isPrimitive = function (UDE) {
    var i, _UCE = ["undefined", "function", "string", "number", "object"];
    return _UCE.some(function (UCE, UIE) {
        return (typeof UDE) == UCE;
    });
}

/**
* 判断是否为event对象
*
* @param  {event} 判断是否为event对象
* @return  {boolean} 是否空event对象
*/
U.Ut.isEvent = function (UDE) {
    if (UDE) {
        if (UDE == event) { return true; } //直接判断当前对象
        else if (event && event.constructor) { //通过链接判断
            return U.MS.Event.test(UDE.constructor.toString());
        }
        else if (typeof UDE == "object") { //判断srcElement
            return UDE.srcElement !== undefined;
        }
    }
}

//
/**
* 判断对象是否为hemlcontrol
*
* @param  {element} 元素
* @return  {boolean} 判断是否为正常元素
*/
U.Ut.IHtmlC = function (UDOD) {
    return UDOD.nodeType != null || UDOD == window || UDOD == document || UDOD.frames != null;
}

/**
* 判断是否为元素
*
* @param  {element} 元素
* @return  {boolean} 返回是否为元素 同时不为文本元素
*/
U.Ut.isElement = function (UDOD) {
    return !!(UDOD && UDOD.nodeType === 1);
}

/**
* 函数的作用是给已有的集合添加新的属性。
*说明：此函数代替U.Json中的Add方法，以避免调试难调，速度降低的问题
* @param  {object} U.CD的自定义变量或者Array,Object等系统变量
* @param  {object} 属性的集合，形如：{ "domain": "1473.cn", "SystemId": 0}
*/
U.Ut.AddObj = function (obj1, obj2) {
    for (var i in obj2) {
        if (obj2.hasOwnProperty(i)) {
            obj1[i] = obj2[i];
        }
    }
    return obj2;
}

/**
* 对象数组，需要批量给对象添加属性。
* @param  {array} U.CD的自定义变量或者Array,Object等系统变量
* @param  {object} 属性的集合，形如：{ "domain": "1473.cn", "SystemId": 0}
*/
U.Ut.AddArr = function (UDE, UAE) {
    for (var i = 0; i < UDE.length; i++) {
        U.Ut.AddObj(UDE[i], UAE);
    }
}

/**
* 此函数代替U.Json中的Add方法，以避免调试难调，速度降低的问题。
* @param  {object 、 array} 自定义变量或者Array,Object等系统变量，
* @param  {object} 属性的集合，形如：{ "domain": "1473.cn", "SystemId": 0}
*/
U.Ut.AddProperty = function (UDE, UAE) {
    //判断是集合或者集合数组，分别调用上2个函数。
    U.Ut.isArray(UDE) ? U.Ut.AddArr(UDE, UAE) : U.Ut.AddObj(UDE, UAE);
}