復(fù)制代碼 代碼如下:

 /** 
 * @author zxub 2006-06-01 
 * 狀態(tài)信息顯示類，用var Status=new function()定義，可以靜態(tài)引用其中的方法 
 * 一般情況下為function Status()，這樣不能靜態(tài)引用其中的方法，需要通過對象來引用 
 */ 
var Status=new function() 
{ 
    this.statusDiv=null; 

    /** 
     * 初始化狀態(tài)顯示層 
     */ 
    this.init=function() 
    { 
        if (this.statusDiv!=null) 
        { 
            return; 
        } 
        var body = document.getElementsByTagName("body")[0]; 
        var div = document.createElement("div"); 
        div.style.position = "absolute"; 
        div.style.top = "50%"; 
        div.style.left = "50%"; 
        div.style.width = "280px"; 
        div.style.margin = "-50px 0 0 -100px";         
        div.style.padding = "15px"; 
        div.style.backgroundColor = "#353555"; 
        div.style.border = "1px solid #CFCFFF"; 
        div.style.color = "#CFCFFF"; 
        div.style.fontSize = "14px"; 
        div.style.textAlign = "center"; 
        div.id = "status"; 
        body.appendChild(div); 
        div.style.display="none"; 
        this.statusDiv=document.getElementById("status"); 
    } 

    /** 
     * 設(shè)置狀態(tài)信息 
     * @param _message:要顯示的信息 
     */     
    this.showInfo=function(_message) 
    {       
        if (this.statusDiv==null) 
        { 
            this.init(); 
        }   
        this.setStatusShow(true); 
        this.statusDiv.innerHTML = _message;         
    } 

    /** 
     * 設(shè)置狀態(tài)層是否顯示 
     * @param _show:boolean值，true為顯示，false為不顯示 
     */  
    this.setStatusShow=function(_show) 
    {       
        if (this.statusDiv==null) 
        { 
            this.init(); 
        }  
        if (_show) 
        { 
            this.statusDiv.style.display=""; 
        } 
        else 
        { 
            this.statusDiv.innerHTML=""; 
            this.statusDiv.style.display="none"; 
        } 
    } 
} 

/** 
 * @author zxub 
 * 用于存放通道名稱及通信對象的類，這樣可以通過不同通道名稱來區(qū)分不同的通信對象 
 */ 
function HttpRequestObject() 
{ 
    this.chunnel=null; 
    this.instance=null; 
} 

/** 
 * @author zxub 
 * 通信處理類，可以靜態(tài)引用其中的方法 
 */ 
var Request=new function() 
{ 
    this.showStatus=true; 

    //通信類的緩存 
    this.httpRequestCache=new Array(); 

    /** 
     * 創(chuàng)建新的通信對象 
     * @return 一個新的通信對象 
     */ 
    this.createInstance=function() 
    { 
        var instance=null; 
        if (window.XMLHttpRequest) 
        { 
            //mozilla 
            instance=new XMLHttpRequest(); 
            //有些版本的Mozilla瀏覽器處理服務(wù)器返回的未包含XML mime-type頭部信息的內(nèi)容時會出錯。因此，要確保返回的內(nèi)容包含text/xml信息 
            if (instance.overrideMimeType) 
            { 
                instance.overrideMimeType="text/xml"; 
            } 
        } 
        else if (window.ActiveXObject) 
        { 
            //IE 
            var MSXML = ['MSXML2.XMLHTTP.5.0', 'Microsoft.XMLHTTP', 'MSXML2.XMLHTTP.4.0', 'MSXML2.XMLHTTP.3.0', 'MSXML2.XMLHTTP']; 
            for(var i = 0; i < MSXML.length; i++) 
            { 
                try 
                { 
                    instance = new ActiveXObject(MSXML[i]); 
                    break; 
                } 
                catch(e) 
                {                     
                } 
            } 
        } 
        return instance; 
    } 

    /** 
     * 獲取一個通信對象 
     * 若沒指定通道名稱，則默認通道名為"default" 
     * 若緩存中不存在需要的通信類，則創(chuàng)建一個，同時放入通信類緩存中 
     * @param _chunnel:通道名稱，若不存在此參數(shù)，則默認為"default" 
     * @return 一個通信對象，其存放于通信類緩存中 
     */ 
    this.getInstance=function(_chunnel) 
    { 
        var instance=null; 
        var object=null; 
        if (_chunnel==undefined)//沒指定通道名稱 
        { 
            _chunnel="default"; 
        } 
        var getOne=false; 
        for(var i=0; i<this.httpRequestCache; i++) 
        { 
            object=HttpRequestObject(this.httpRequestCache[i]); 
            if (object.chunnel==_chunnel) 
            { 
                if (object.instance.readyState==0 || object.instance.readyState==4) 
                { 
                    instance=object.instance; 
                } 
                getOne=true; 
                break;                     
            } 
        } 
        if (!getOne) //對象不在緩存中，則創(chuàng)建 
        { 
            object=new HttpRequestObject(); 
            object.chunnel=_chunnel; 
            object.instance=this.createInstance(); 
            this.httpRequestCache.push(object); 
            instance=object.instance; 
        }          
        return instance; 
    } 

    /** 
     * 客戶端向服務(wù)端發(fā)送請求 
     * @param _url:請求目的 
     * @param _data:要發(fā)送的數(shù)據(jù) 
     * @param _processRequest:用于處理返回結(jié)果的函數(shù)，其定義可以在別的地方，需要有一個參數(shù)，即要處理的通信對象 
     * @param _chunnel:通道名稱，默認為"default" 
     * @param _asynchronous:是否異步處理，默認為true,即異步處理 
     */ 
    this.send=function(_url,_data,_processRequest,_chunnel,_asynchronous) 
    { 
        if (_url.length==0 || _url.indexOf("?")==0) 
        { 
            Status.showInfo("由于目的為空，請求失敗，請檢查!"); 
            window.setTimeout("Status.setStatusShow(false)",3000); 
            return; 
        } 
        if (this.showStatus) 
        { 
            Status.showInfo("請求處理中，請稍候");   
        } 
        if (_chunnel==undefined || _chunnel=="") 
        { 
            _chunnel="default"; 
        } 
        if (_asynchronous==undefined) 
        { 
            _asynchronous=true; 
        } 
        var instance=this.getInstance(_chunnel); 
        if (instance==null) 
        { 
            Status.showInfo("瀏覽器不支持ajax，請檢查!") 
            window.setTimeout("Status.setStatusShow(false)",3000); 
            return; 
        }   
        if (_asynchronous==true && typeof(_processRequest)=="function") 
        { 
            instance.onreadystatechange=function() 
            { 
                if (instance.readyState == 4) // 判斷對象狀態(tài) 
                { 
                    if (instance.status == 200) // 信息已經(jīng)成功返回，開始處理信息 
                    {                  
                        _processRequest(instance); 
                        Status.setStatusShow(false); 
                        Request.showStatus=true;                    
                    } 
                    else 
                    { 
                        Status.showInfo("您所請求的頁面有異常，請檢查!"); 
                        window.setTimeout("Status.setStatusShow(false)",3000); 
                    } 
                } 
            } 
        } 
        //_url加一個時刻改變的參數(shù)，防止由于被瀏覽器緩存后同樣的請求不向服務(wù)器發(fā)送請求 
        if (_url.indexOf("?")!=-1) 
        { 
            _url+="&requestTime="+(new Date()).getTime(); 
        } 
        else 
        { 
            _url+="?requestTime="+(new Date()).getTime(); 
        } 
        if (_data.length==0) 
        { 
            instance.open("GET",_url,_asynchronous);           
            instance.send(null);             
        } 
        else 
        { 
            instance.open("POST",_url,_asynchronous); 
            instance.setRequestHeader("Content-Length",_data.length); 
            instance.setRequestHeader("Content-Type","application/x-www-form-urlencoded"); 
            instance.send(_data); 
        } 
        if (_asynchronous==false && typeof(_processRequest)=="function") 
        { 
            _processRequest(instance); 
            if (Request.showStatus) 
            { 
                Status.setStatusShow(false); 
            } 
            else 
            { 
                Request.showStatus=true; 
            } 
        } 
    } 

    /** 
     * 間隔一段時間持續(xù)發(fā)送請求，只用于異步處理，只用于GET方式 
     * @param _interval:請求間隔，以毫秒計 
     * @param _url:請求地址 
     * @param _processRequest:用于處理返回結(jié)果的函數(shù)，其定義可以在別的地方，需要有一個參數(shù)，即要處理的通信對象 
     * @param _chunnel:通道名稱，默認為"defaultInterval"，非必添 
     */ 
    this.intervalSend=function(_interval,_url,_processRequest,_chunnel) 
    { 
        var action=function() 
        { 
            if (_chunnel==undefined) 
            { 
                _chunnel="defaultInterval"; 
            } 
            var instance=Request.getInstance(_chunnel); 
            if (instance==null) 
            { 
                Status.showInfo("瀏覽器不支持ajax，請檢查!") 
                window.setTimeout("Status.setStatusShow(false)",3000); 
                return; 
            } 
            if (typeof(_processRequest)=="function") 
            { 
                instance.onreadystatechange=function() 
                { 
                    if (instance.readyState == 4) // 判斷對象狀態(tài) 
                    { 
                        if (instance.status == 200) // 信息已經(jīng)成功返回，開始處理信息 
                        { 
                            _processRequest(instance); 
                        } 
                        else 
                        { 
                            Status.showInfo("您所請求的頁面有異常，請檢查!"); 
                            window.setTimeout("Status.setStatusShow(false)",3000); 
                        } 
                    } 
                } 
            } 
            //_url加一個時刻改變的參數(shù)，防止由于被瀏覽器緩存后同樣的請求不向服務(wù)器發(fā)送請求 
            if (_url.indexOf("?")!=-1) 
            { 
                _url+="&requestTime="+(new Date()).getTime(); 
            } 
            else 
            { 
                _url+="?requestTime="+(new Date()).getTime(); 
            } 
            instance.open("GET",_url,true); 
            instance.send(null); 
        } 
        window.setInterval(action,_interval);         
    } 
} 

var Env=new function() 
{    
    this.funcList=new Array(); 

    this.envPath=null; 

    this.getPath=function() 
    { 
        this.envPath=document.location.pathname; 
        this.envPath=this.envPath.substring(0,this.envPath.lastIndexOf("/")+1);         
        var _scripts=document.getElementsByTagName("script"); 
        var _envPath=null; 
        var _scriptSrc=null; 
        for (var i=0; i<_scripts.length; i++) 
        { 
            _scriptSrc=_scripts[i].getAttribute("src"); 
            if (_scriptSrc && _scriptSrc.indexOf("env.js")!=-1) 
            { 
                break; 
            } 
        } 
        if (_scriptSrc!=null) 
        { 
            if (_scriptSrc.charAt(0)=='/') 
            { 
                this.envPath=_scriptSrc.substr(0,_scriptSrc.length-6); 
            } 
            else 
            { 
                this.envPath=this.envPath+_scriptSrc.substr(0,_scriptSrc.length-6); 
            } 
        }         
    } 
    this.getPath();     

    /** 
     * 按需獲取需要的js文件 
     * @param _jsName:js文件路徑，若為相對路徑，則是對應(yīng)env.js的相對路徑，也可以用絕對路徑 
     * @param _language:對返回函數(shù)進行處理的語言，默認為JScript，可不填 
     */ 
    this.require=function(_jsName,_language) 
    { 
        var _absJsName=null; 
        if (_jsName.charAt(0)=='/') 
        { 
            _absJsName=_jsName; 
        } 
        else 
        { 
            _absJsName=this.envPath+_jsName; 
        }         
        if (!Env.funcList[_absJsName]) 
        { 
            Env.funcList[_absJsName]="finished";   
            var processJs=function(_instance) 
            { 
                //為兼容firefox做判斷 
                if (_language!=undefined) 
                { 
                    if (window.execScript) 
                    { 
                        window.execScript(_instance.responseText,_language); 
                    } 
                    else 
                    { 
                        window.eval(_instance.responseText,_language); 
                    }                                        
                } 
                else 
                { 
                    if (window.execScript) 
                    { 
                        window.execScript(_instance.responseText); 
                    } 
                    else 
                    { 
                        window.eval(_instance.responseText); 
                    }                     
                }                
            } 
            Request.showStatus=false; 
            Request.send(_absJsName,"",processJs,"",false); 
        } 
    } 

    /** 
     * 該函數(shù)的效果是在應(yīng)用它的script塊后加一個script塊 
     * 是由document.write在script塊中的執(zhí)行順序決定的 
     */ 
    this.getJs=function(_jsName) 
    { 
        if (!Env.funcList[_jsName]) 
        { 
            Env.funcList[_jsName]="finished"; 
            document.write('<scr'+'ipt type="text/javascript" src="'+_jsName+'"></'+'scr'+'ipt>'); 
        } 
    } 
} 

/** 
 * ajax調(diào)用遠程頁面后，遠程頁面中script塊未執(zhí)行的處理 
 */ 
function reloadJs(_language) 
{ 
    var _c=document.getElementsByTagName("SCRIPT"); 
    for (var i=0;i<_c.length;i++) 
    { 
        if (_c[i].src) 
        { 
            var _s=document.createElement("script"); 
            _s.type="text/javascript"; 
            _s.src=_c[i].src; 
            //為兼容firefox不用_c[0].insertAdjacentElement("beforeBegin",_s) 
            _c[0].parentNode.insertBefore(_s,_c[0]);             
            _c[i].parentNode.removeChild(_c[i]); 
        } 
        else if (_c[i].text) 
        { 
            if (_language!=undefined) 
            { 
                if (window.execScript) 
                { 
                    window.execScript(_c[i].text,_language); 
                } 
                else 
                { 
                    window.eval(_c[i].text,_language); 
                } 
            } 
            else 
            { 
                if (window.execScript) 
                { 
                    window.execScript(_c[i].text); 
                } 
                else 
                { 
                    window.eval(_c[i].text); 
                } 
            } 
        } 
    } 
}