///////////////////////////////////////////////////////////////////////////////////
// 文件名 ：    Common.js
// 功  能 ：    公用模块
//      包含一下函数：
//          浏览器检查函数
//          字符串处理函数
//          日期检查函数
//          身份证处理函数
//          数值校验函数
//          DOM&XML 函数
//
// 编写者 ：    Enjsky   enjsky@shortime.cn
//
// 日  期 ：    2002/8/xx ---- 2002/10/26
//
///////////////////////////////////////////////////////////////////////////////////


//+------------------------------------
// 生成异常
//-------------------------------------
function err(sDesc, iNumber)
{
    var number = iNumber ? iNumber : 0;
    e = new Error(number, sDesc);
    throw e;
}

//+------------------------------------
// 在新窗口查看 xml 字符串
//-------------------------------------
function seeXML(sXML)
{
    var w = window.open("");
    w.document.write("<xmp>" + sXML + "</xmp>");
}

//+------------------------------------
// 输出提示
//-------------------------------------
function printf(sMsg)
{
    alert(sMsg);
}

//-----------------------------------------------
// 取随机数
//-----------------------------------------------
function getRandom () {
    if((navigator.appName == "Netscape") && 
      ((navigator.appVersion.indexOf("2.0") >= 0) || 
      (navigator.appVersion.indexOf("Win3") >= 0))) {
        now = new Date();
        // pseudo random
        return (now.getTime() % 1000000) / 1000000;
    } else {
        return Math.random();
    }
}

//-----------------------------------------------
// 替换 > < 为 &gt; &lt;
//-----------------------------------------------
function re(s)
{
    return s.replace(/>/g, "&gt;").replace(/</g, "&lt;");
}

//-----------------------------------------------
// 替换 &gt; &lt; 为 > <
//-----------------------------------------------
function unRe(s)
{
    return s.replace(/&gt;/g, ">").replace(/&lt;/g, "<");
}


///////////////////////////////////////////////////////////////////////////////////
// 浏览器检查
///////////////////////////////////////////////////////////////////////////////////

if (!hasSupportBehaviors()) {
    alert("很抱歉你的浏览器不支持 Behaviors 特性\n只有 IE5.5 以上的浏览器才支持！");
}

//+------------------------------------
// 检查浏览器是否支持 Behaviors （IE5.5 以上才支持）
//-------------------------------------
function hasSupportBehaviors()
{
    if (typeof(hasSupportBehaviors.support) != "undefined")
        return hasSupportBehaviors.support;

    var ua = window.navigator.userAgent;
    var msiePos = ua.indexOf("MSIE");
    var msieVer = 0;
    var behaviorsAvailable = false;
    var iHandle = 0;
    if (msiePos >= 0) {
        msieMajorVer = parseInt(ua.charAt(msiePos + 5));
        msieMinorVer = parseInt(ua.charAt(msiePos + 7));
        if (msieMajorVer >= 5) {
            if (((msieMajorVer == 5) && (msieMinorVer >= 5)) ||
                (msieMajorVer > 5))
            {
                hasSupportBehaviors.support = true;
            }
        }
    }
    return hasSupportBehaviors.support;
}

//+------------------------------------
// 检查浏览器是否支持
//-------------------------------------
function hasSupport()
{
    if (typeof(hasSupport.support) != "undefined")
        return hasSupport.support;

    var ie55 = /msie 5\.[56789]/i.test(navigator.userAgent);

    hasSupport.support = (typeof(document.implementation) != "undefined" &&
            document.implementation.hasFeature("html", "1.0") || ie55)

    return hasSupport.support;
}




///////////////////////////////////////////////////////////////////////////////////
// 字符串处理
///////////////////////////////////////////////////////////////////////////////////

//+------------------------------------
// trim     去除字符串两端的空格
// trimL    除去字符串左边的空格
// trimR    除去字符串右边的空格
// stripBlanks  剥去字符串中的空格
// lenB     返回指定字符串中的字节个数(备注:中文字符占2个字节)
// contain  是否包含指定字符串
//-------------------------------------
String.prototype.trim=function(){return this.replace(/(^\s*)|(\s*$)/g,"")}
String.prototype.trimL=function(){return this.replace(/(^\s*)/g,"")}
String.prototype.trimR=function(){return this.replace(/(\s*$)/g,"")}
String.prototype.stripBlanks=function(){return this.replace(/\s/g, "")}
String.prototype.lenB=function(){try{return this.match(/[^\x00-\xff]/g).length+this.length}catch(e){return this.length}}
String.prototype.contain=function(str){return (this.indexOf(str)!=-1)?true:false}




///////////////////////////////////////////////////////////////////////////////////
// 日期检查函数
///////////////////////////////////////////////////////////////////////////////////

//+------------------------------------
// 判断是否是闰年
//-------------------------------------
function isLeapYear(iYear){return ((!(iYear%4)&&(iYear%100))||!(iYear%400))?true:false}

//+------------------------------------
// 处理小于1000的年份，将其加上1900
//-------------------------------------
function y2k(iYear){return (iYear<1000)?iYear+1900:iYear}

//+------------------------------------
// 根据YYYYMMDD日期格式获得日期对象
//-------------------------------------
function getRevFMTDate(strSourc)
{
    var lngYear = parseInt(strSourc.substr(0,4))
    var lngMonth = parseInt(strSourc.substr(4,2)) - 1;
    var lngDay = parseInt(strSourc.substr(6))
    return(new Date(lngYear,lngMonth,lngDay));
}

//+------------------------------------
// 获得YYYYMMDD日期格式
//-------------------------------------
function getFMTDate(datSourc)
{
	var y = datSourc.getFullYear() + "";
	var m = datSourc.getMonth() + 1 + "";
	m = m.length == 1 ? "0" + m : m;
	var d = datSourc.getDate()+"";
	d = d.length == 1 ? "0" + d : d;
	return y + m + d;
}

//+------------------------------------
// 获得系统当前日期
//-------------------------------------
function getNowDate()
{
    var today = new Date();
    var y = today.getFullYear() + "";
    var m = today.getMonth() + 1 + "";
    m = m.length == 1 ? "0" + m : m;
    var d = today.getDate()+"";
    d = d.length == 1 ? "0" + d : d;
    return y + m + d;
}

//+------------------------------------
// 获得系统当前时间
//-------------------------------------
function getNowTime()
{
    var today = new Date();
    var h = today.getHours() + "";
    h = h.length == 1 ? "0" + h : h;
    var m = today.getMinutes() + "";
    m = m.length == 1 ? "0" + m : m;
    var s = today.getSeconds() + "";
    s = s.length == 1 ? "0" + s : s;
    return h + m + s;
}

//+------------------------------------
// 判断指定日期是否正确
// 当输入参数为verifyDate(dd,mm,ccyy)时，表示要检查年，月，日
// 当输入参数为verifyDate(dd,mm) 表示默认年为当前年
// 当输入参数为verifyDate(dd)    表示默认年，月为当前年月
// 注意：输入月份保证在1-12以内。
//-------------------------------------
function verifyDate(day,month,year)
{
    if (!day) return false;
    var iToday = new Date();
    month = month ? month-1 : iToday.getMonth();
    year = year ? y2k(parseInt(year)) : iToday.getFullYear();
    var iDate = new Date(year,month,day);
    if ((iDate.getFullYear() == year) && (iDate.getMonth() == month) && (iDate.getDate() == day))
        return true;
    else
        return false;
}

//+------------------------------------
// 判断指定时间格式是否正确
// 注意：输入小时保证在0(午夜)-23(晚上11点)
//      输入分钟保证在0-59
//      输入秒数保证在0-59
//-------------------------------------
function verifyTime(hh,mm,ss)
{
    var iDate = new Date(1977,10,27,hh,mm,ss);
    if ((iDate.getHours() == hh) && (iDate.getMinutes() == mm) && (iDate.getSeconds() == ss))
        return true;
    else
        return false;
}

//+------------------------------------
// 判断指定日期时间格式是否正确
// 注意：输入小时保证在0(午夜)-23(晚上11点)
//      输入分钟保证在0-59
//      输入秒数保证在0-59
//-------------------------------------
function verifyDateTime(year,month,day,hh,mm,ss)
{
    if (!verifyDate(day,month,year)) return false;
    var iToday = new Date();
    return verifyTime(hh,mm,ss);
}




///////////////////////////////////////////////////////////////////////////////////
// 身份证处理函数
///////////////////////////////////////////////////////////////////////////////////

//+------------------------------------
// 根据17位身份证算出18位身份证
//-------------------------------------
function CalID_17to18(sId)
{
    var aW = new Array(1,2,4,8,5,10,9,7,3,6,1,2,4,8,5,10,9,7);
    var aA = new Array("1","0","X","9","8","7","6","5","4","3","2");
    var aP = new Array(17);
    var aB = new Array(17);
    var i,iSum = 0;

    for (i=1;i<18;i++)
        aP[i] = sId.substr(17-i, 1);
    for (i=1;i<18;i++) {
        aB[i] = parseInt(aP[i]) * parseInt(aW[i]);
        iSum += aB[i];
    }
    return sId + aA[iSum%11];
}

//+------------------------------------
// 根据15位身份证算出18位身份证
//-------------------------------------
function CalID_15to18(sId)
{
    return CalID_17to18(sId.substr(0,6) + "19" + sId.substr(6));
}

//+------------------------------------
// 把15或17位身份证升级位18位，并进行判断
//-------------------------------------
function UpID(sId)
{
    var s = sId.trim();
    if (s.length == 15) {
        if (isNaN(sId)) return false;
        if (verifyDate(s.substr(10,2),s.substr(8,2),s.substr(6,2)))
            return CalID_15to18(s);
        else
            return false;
    }
    else if (s.length == 17) {
        if (isNaN(s)) return false;
        if (verifyDate(s.substr(12,2),s.substr(10,2),s.substr(6,4)))
            return CalID_17to18(s);
        else
            return false;
    }
    else if (s.length == 18) {
        if (isNaN(s.substr(0,17))) return false;
        if (verifyDate(s.substr(12,2),s.substr(10,2),s.substr(6,4))) {
            if (CalID_17to18(s.substr(0,17)) == s)
                return s;
            else
                return false;
        }
        else
            return false;
    }
    return false;
}

//+------------------------------------
// 从身份证号码中提取出生日期
//-------------------------------------
function getBirthday(sId)
{
    var s = UpID(sId);
    return s ? s.substr(6,8) : false;
}

//+------------------------------------
// 从身份证号码中提取性别
// (0--未知的性别; 1--男; 2--女)
//-------------------------------------
function getSex(sId)
{
    var s = UpID(sId);
    return s ? (parseInt(s.substr(16,1))%2 ? "1" : "2") : "0";
}




///////////////////////////////////////////////////////////////////////////////////
// 数值校验函数
///////////////////////////////////////////////////////////////////////////////////

//+------------------------------------
// 校验身份证
//-------------------------------------
function isIDCard(sValue)
{
    return UpID(sValue) ? true : false;
}

//+------------------------------------
// 校验日期格式是否为yyyyMMdd
//-------------------------------------
function isDate(sValue)
{
    var s = sValue.trim();
    if (s.length != 8)
        return false;
    else if (isNaN(s))
        return false;
    else
        return verifyDate(s.substr(6),s.substr(4,2),s.substr(0,4));
}


//+------------------------------------
// 校验时间格式是否为hhMMss(24小时制)
//-------------------------------------
function isTime(sValue)
{
    var s = sValue.trim();
    if (s.length != 6)
        return false;
    else if (isNaN(s))
        return false;
    else
        return verifyTime(s.substr(0,2),s.substr(2,2),s.substr(4,2));
}


//+------------------------------------
// 校验日期＋时间格式是否为YYYYmmDDhhMMss
//-------------------------------------
function isDateTime(sValue)
{
    var s = sValue.trim();
    if (s.length != 14)
        return false;
    else if (isNaN(s))
        return false;
    else
        return verifyDateTime(s.substr(0,4),s.substr(4,2),s.substr(6,2),
                s.substr(8,2),s.substr(10,2),s.substr(12,2));
}

//+------------------------------------
// 是否是整数
//-------------------------------------
function isInt(sValue)
{
    return /^\d*$/.test(sValue);
}

//+------------------------------------
// 是否是浮点数
//-------------------------------------
function isFloat(sValue)
{
    return (/^\d*\.\d+$/.test(sValue) || /^\d*$/.test(sValue));
}

//+------------------------------------
// 是否是数字
//-------------------------------------
function isNumber(sValue)
{
    return isInt(sValue) || isFloat(sValue);
}

//+------------------------------------
// 是否是字母
//-------------------------------------
function isLetter(sValue)
{
    return /^[A-Za-z]*$/.test(sValue);
}

//+------------------------------------
// 是否是字母或数字
//-------------------------------------
function isLetterOrNumber(sValue)
{
    return /^\w*$/.test(sValue);
}

//+------------------------------------
// 是否是空
//-------------------------------------
function isBlank(sValue)
{
    return /^\s*$/.test(sValue);
}

//+------------------------------------
// 是否是Email
//-------------------------------------
function isEmail(sEmail){
    return /^([a-zA-Z0-9_-])+@([a-zA-Z0-9_-])+(\.[a-zA-Z0-9_-])+/g.test(sEmail);
}


///////////////////////////////////////////////////////////////////////////////////
// DOM&XML 函数
///////////////////////////////////////////////////////////////////////////////////

// IE55 has a serious DOM1 bug... Patch it!
if (/msie 5\.[56789]/i.test(navigator.userAgent)) {
    document._getElementsByTagName = document.getElementsByTagName;
    document.getElementsByTagName = function (sTagName) {
        if (sTagName == "*")
            return document.all;
        else
            return document._getElementsByTagName(sTagName);
    };
}

//+------------------------------------
// 创建 XMLDocument 对象
//-------------------------------------
function createDOMDocument()
{
    try {
        var objXML = new ActiveXObject("Msxml2.DOMDocument");
        objXML.async = false;
        return objXML
    }
    catch (e) {
        return null;
    }
}

//+------------------------------------
// 设置节点的属性
// objXML ：        DOM         DOM 对象
// nodePath ：      String      节点 xPath 路径(由根节点起至该节点)
// attribName ：    String      属性名
// attribValue ：   String      属性值
//-------------------------------------
function setAttribValue(objXML, nodePath, attribName, attribValue)
{
    var node = objXML.selectSingleNode("//" + nodePath);
    if (node) {
        node.setAttribute(attribName, attribValue);
        return true;
    }
    return false;
}

//+------------------------------------
// 获得节点的属性
// objXML ：        DOM         DOM 对象
// nodePath ：      String      节点 xPath 路径(由根节点起至该节点)
// attribName ：    String      属性名
// index ：         Integer     当有多个节点路径相同时，用于索引
//-------------------------------------
function getAttribValue(objXML, nodePath, attribName, index)
{
    try {
        var objNodeList = objXML.selectNodes("//" + nodePath);
        if (objNodeList.length > 0) {
            if (index) {
                return objNodeList.item(index).getAttribute(attribName);
            }
            else {
                return objNodeList.item(0).getAttribute(attribName);
            }
        }
    }
    catch (e) {}
    return null;
}

//+------------------------------------
// 创建根节点
// nodeName ： String       根节点名
//-------------------------------------
function makeRootNode(nodeName)
{
    try {
        var objXML = createDOMDocument();
        objXML.loadXML("<" + nodeName + "/>");
        if (objXML.parseError.errorCode != 0) {
            throw 0;
        }
        return objXML;
    }
    catch (e) {
        return null;
    }
}

//+------------------------------------
// 设置节点值
// objXML ：    DOM         DOM 对象
// nodePath ：  String      节点 xPath 路径(由根节点起至该节点)
// nodeValue ： String      节点值
//-------------------------------------
function setNodeValue(objXML, nodePath, nodeValue)
{
    try {
        var node, path, value;
        var nodes = [];
        var nodeNameList = nodePath.split("/");
        var len = nodeNameList.length - 1;

        if (!objXML.documentElement) {
            throw 0;
        }

        for (var i = 0; i < len; i++) {
            path = nodeNameList[0];
            for (var j=1; j<=i+1; j++)
                path += "/" + nodeNameList[j];
            value = (i != len-1) ? "" : nodeValue;
            node = objXML.selectSingleNode("//" + path);
            if (!node) {
                var pos = path.lastIndexOf("/");
                node = objXML.createElement(path.substr(pos+1));
            }
            if (value != "") node.text = value;
            nodes[i] = node;
        }

        node = nodes[0];
        objXML.documentElement.appendChild(node);
        for (i=1; i<nodes.length; i++) {
            node = node.appendChild(nodes[i]);
        }
        return true;
    }
    catch (e) {
        return false;
    }
}

//+------------------------------------
// 获得节点值
// objXML ：    DOM         DOM 对象
// nodePath ：  String      节点 xPath 路径(由根节点起至该节点)
// index ：     Integer     当有多个节点路径相同时，用于索引
//-------------------------------------
function getNodeValue(objXML, nodePath, index)
{
    try {
        var objNodeList = objXML.selectNodes("//" + nodePath);
        if (objNodeList.length > 0) {
            if (index) {
                return objNodeList.item(index).text;
            }
            else {
                return objNodeList.item(0).text;
            }
        }
    }
    catch (e) {}
    return "";
}

//+------------------------------------
// 设置节点对象
// objXML ：    DOM          DOM 对象
// nodePath ：  String       节点 xPath 路径(由根节点起至该节点)
// sXML ：      String       XML 字符串
//-------------------------------------
function setNodeDOM(objXML, nodePath, sXML)
{
    try {
        if (!objXML.documentElement) {
            throw 0;
        }

        var node = objXML.selectSingleNode("//" + nodePath);
        if (!node) {
            setNodeValue(objXML, nodePath, "");
            node = objXML.selectSingleNode("//" + nodePath);
        }

        var objTXML = createDOMDocument();
        objTXML.loadXML(sXML);
        if (objTXML.parseError.errorCode != 0) {
            throw 0;
        }

        while (objTXML.documentElement.hasChildNodes()) {
            node.appendChild(objTXML.documentElement.firstChild);
        }

        return true;
    }
    catch (e) {
        return false;
    }
}

//+------------------------------------
// 获得节点对象
// objXML ：    DOM         DOM 对象
// nodePath ：  String      节点 xPath 路径(由根节点起至该节点)
// index ：     Integer     当有多个节点路径相同时，用于索引
//-------------------------------------
function getNodeDOM(objXML, nodePath, index)
{
    try {
        var objNodeList = objXML.selectNodes("//" + nodePath);
        if (objNodeList.length > 0) {
            if (index) {
                return objNodeList.item(index);
            }
            else {
                return objNodeList.item(0);
            }
        }
    }
    catch (e) {}
    return null;
}

//+------------------------------------
// 生成 DataInfo XML 数据
// arr_fieldName ： Array       节点名数组
// arr_nodeValue ： Array       节点值数组
// arr_showValue ： Array       节点sv属性值数组
// arr_type ：      Array       节点值的类型
//  (true: XML字符串; false: 文本值)
//-------------------------------------
function buildDataInfo(arr_fieldName, arr_nodeValue, arr_showValue, arr_valueType)
{
    var nodeRoot = "DATAINFO";
    var objXML = makeRootNode(nodeRoot);
    if (!objXML) return;
    var len = arr_fieldName.length;
    for (var i = 0; i < len; i++) {
        var path = nodeRoot + "/" + arr_fieldName[i];
        if (arr_valueType[i]) {
            setNodeDOM(objXML, path, arr_nodeValue[i]);
        }
        else {
            setNodeValue(objXML, path, arr_nodeValue[i]);
            if (arr_showValue[i] != "") {
                setAttribValue(objXML, path, "sv", arr_showValue[i]);
            }
        }
    }
    return objXML;
}

//+------------------------------------
// 生成一个查询子条件
// sFiledName : String      字段名
// sOperation : String      操作类型
// sValue :     String      查询值
// sSV :        String      当查询值为编码时的文本值
//-------------------------------------
function makeCondition(sFiledName, sOperation, sValue, sSV)
{
    try {
        var sXML = "<CONDITION alias='' datatype=''>" +
            "<FIELDNAME sv='" + sSV + "'>" + sFiledName + "</FIELDNAME>" +
            "<OPERATION>" + sOperation + "</OPERATION>" +
            "<VALUE>" + re(sValue) + "</VALUE>" +
            "</CONDITION>";
        var xmlCondition = createDOMDocument();
        xmlCondition.loadXML(sXML);
        if (xmlCondition.parseError.errorCode != 0) {
            throw 0;
        }
        return xmlCondition;
    }
    catch (e) {
        return null;
    }
}

//+------------------------------------
// 增加一个查询条件组
// sType :          String      逻辑关系类型
// xmlConditionA :  XML       查询条件A
// xmlConditionB :  XML       查询条件B
//-------------------------------------
function addConditionItem(sType, xmlConditionA, xmlConditionB)
{
    try  {
        var sXML = "<CONDITIONS>" +
            "<TYPE>" + sType + "</TYPE>" +
            "</CONDITIONS>";
        var xmlConditions = createDOMDocument();
        xmlConditions.loadXML(sXML);
        if (xmlConditions.parseError.errorCode != 0) {
            throw 0;
        }
        if (xmlConditionA) {
             xmlConditions.documentElement.appendChild(xmlConditionA.documentElement.cloneNode(true));
        }
        if (xmlConditionB) {
             xmlConditions.documentElement.appendChild(xmlConditionB.documentElement.cloneNode(true));
        }
        return xmlConditions;
    }
    catch (e) {
        return null;
    }
}

//+------------------------------------
// 由一组查询子条件,构造条件组
// sType :          String    逻辑关系类型
// arr_xmlCondition : XML     查询子条件数组(它们之间的逻辑关系是与)
//-------------------------------------
function makeConditions(sType, arr_xmlCondition)
{
    try {
        var xmlConditions = null;
        if (arr_xmlCondition.length >= 2) {
            xmlConditions = addConditionItem(sType, arr_xmlCondition[0], arr_xmlCondition[1]);
            for (var i=2; i<arr_xmlCondition.length; i++) {
                xmlConditions = addConditionItem(sType, xmlConditions, arr_xmlCondition[i]);
            }
        }
        else {
            xmlConditions = addConditionItem(sType, arr_xmlCondition[0]);
        }
        return xmlConditions;
    }
    catch (e) {
        return null;
    }
}

//+------------------------------------
// 创建查询条件
// sPredicate :     String      谓词
// xmlConditions :  XML         查询条件
//-------------------------------------
function makeQueryCondition(sPredicate, xmlConditions)
{
    try {
        var sXML = "<?xml version='1.0'?>" +
            "<PKUDOC pkusoft=\"urn=schemas-pkusoft-com\" version=\"2.0\">" +
            "<QUERYCONDITION>" +
            "<PREDICATE>" + sPredicate + "</PREDICATE>" +
            "</QUERYCONDITION>" +
            "</PKUDOC>";
        var xmlDoc = createDOMDocument();
        xmlDoc.loadXML(sXML);
        if (xmlDoc.parseError.errorCode != 0) {
            throw 0;
        }
        xmlDoc.documentElement.firstChild.appendChild(xmlConditions.documentElement);
        return xmlDoc;
    }
    catch (e) {
        return null;
    }
}

//+------------------------------------
// 生成查询条件 XML
// arr_FieldName ： Array       字段名数组
// arr_Logic ：     Array       逻辑关系数组
// arr_Operation ： Array       操作关系数组
// arr_Value ：     Array       条件值数组
// arr_SV ：        Array       条件值的文本数组
//-------------------------------------
function buildConditions(arr_FieldName, arr_Logic, arr_Operation, arr_Value, arr_SV)
{
    var arr_Condition = [];
    for (var i = 0; i < arr_Value.length; i++) {
        var n = arr_Condition.length;
        arr_Condition[n] = makeCondition(arr_FieldName[i], arr_Operation[i], arr_Value[i], arr_SV[i]);
    }

    var xmlConditions = null;
    if (arr_Condition.length >= 2) {
        xmlConditions = addConditionItem(arr_Logic[0], arr_Condition[0], arr_Condition[1]);

        for (var i = 2; i < arr_Condition.length; i++) {
            xmlConditions = addConditionItem(arr_Logic[i-1],
                xmlConditions, arr_Condition[i]);
        }
    }
    else {
        xmlConditions = addConditionItem(arr_Logic[0], arr_Condition[0]);
    }
    var xmlQuery = makeQueryCondition("", xmlConditions);
    return xmlQuery.xml;
}


//+------------------------------------
// 生成给xml信息添加头信息和尾信息
//-------------------------------------
function addXmlHeadFoot(sXml)
{
  try
  {
    var sTmpXML = "<?xml version=\"1.0\"?>" +
      "<PKUDOC pkusoft=\"urn=schemas-pkusoft-com\" version=\"2.0\">" +
      sXml +
      "</PKUDOC>";
    return sTmpXML;
  }
  catch(e)
  {
    return null;
  }
}

//+------------------------------------
// 四舍五入函数
// Dight  输入数字
// How    保留小数位
//-------------------------------------
function  ForDight(Dight,How)  
{  
  Dight = Math.round(Dight*Math.pow(10,How))/Math.pow(10,How);
  return Dight;
}