用ajax动态加载需要的js文件


            习惯了用java，在java中，需要某个类直接import就可以了，所以做javascript的时候也想实现这个效果。 



　　前段时间，用了下dojo，里面的dojo.require的功能很不错，一看代码，晕了，一大堆东西，唉～还是自己写个简单点的，dojo.require可以引入包，我就只做一个导入js文件的。 



　　开始用的document.write，执行顺序不对了，这是在后面进行导入，而我们总是在前面执行中就需要导入的js，这样，执行中就会报“某某未定义”，就是顺序问题了。 



　　接着，我就想用ajax同步（注意：不是异步）调用远程js文件，这里有个问题，就是我们要js文件的时候，不是用绝对路径，就是相对路径，用相对路径的话，以哪个为参照呢？可以用调用js的那个文件为参照，也可以以实现调用功能的js文件为参照，这里，我选择写个 js，实现按需调用其它js，参照也选它。经过一番修改，路径问题解决。但是，读取过来的数据中文会有乱码问题，好在我们做东西都用UTF-8（因为要国际化），所以这里避过了。 



　　远程js内容取到后，就要执行，用eval执行后，发现还是取不到远程js里定义的内容，怪了，猛alert一番后，发现执行eval的上下文范围有问题，我们要的是js在window对象中执行，嗯？window有什么方法没？一找，哈，有个window.execScript方法，ok，试一下，成功，yeah~后来发现在firefox下，不能用window.execScript，找了一下，用window.eval，用法和ie下的window.execScript类似。但是只用window.eval的时候，在ie下有时候会出问题，所以就两种一起用了。 



　　下面是实现远程js安调用的那个js：env.js，我已经习惯用oo写js了







 /** 

 * @author zxub 2006-06-01 

 * 状态信息显示类，用var Status=new function()定义，可以静态引用其中的方法 

 * 一般情况下为function Status()，这样不能静态引用其中的方法，需要通过对象来引用 

 */ 

var Status=new function() 

{ 

  this.statusDiv=null; 

   

  /** 

   * 初始化状态显示层 

   */ 

  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"); 

  } 

   

  /** 

   * 设置状态信息 

   * @param _message:要显示的信息 

   */   

  this.showInfo=function(_message) 

  {    

    if (this.statusDiv==null) 

    { 

      this.init(); 

    }  

    this.setStatusShow(true); 

    this.statusDiv.innerHTML = _message;     

  } 

    

  /** 

   * 设置状态层是否显示 

   * @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 

 * 用于存放通道名称及通信对象的类，这样可以通过不同通道名称来区分不同的通信对象 

 */ 

function HttpRequestObject() 

{ 

  this.chunnel=null; 

  this.instance=null; 

} 



/** 

 * @author zxub 

 * 通信处理类，可以静态引用其中的方法 

 */ 

var Request=new function() 

{ 

  this.showStatus=true; 

   

  //通信类的缓存 

  this.httpRequestCache=new Array(); 

   

  /** 

   * 创建新的通信对象 

   * @return 一个新的通信对象 

   */ 

  this.createInstance=function() 

  { 

    var instance=null; 

    if (window.XMLHttpRequest) 

    { 

      //mozilla 

      instance=new XMLHttpRequest(); 

      //有些版本的Mozilla浏览器处理服务器返回的未包含XML mime-type头部信息的内容时会出错。因此，要确保返回的内容包含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" 

   * 若缓存中不存在需要的通信类，则创建一个，同时放入通信类缓存中 

   * @param _chunnel：通道名称，若不存在此参数，则默认为"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) //对象不在缓存中，则创建 

    { 

      object=new HttpRequestObject(); 

      object.chunnel=_chunnel; 

      object.instance=this.createInstance(); 

      this.httpRequestCache.push(object); 

      instance=object.instance; 

    }      

    return instance; 

  } 

   

  /** 

   * 客户端向服务端发送请求 

   * @param _url:请求目的 

   * @param _data:要发送的数据 

   * @param _processRequest:用于处理返回结果的函数，其定义可以在别的地方，需要有一个参数，即要处理的通信对象 

   * @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) // 判断对象状态 

        { 

          if (instance.status == 200) // 信息已经成功返回，开始处理信息 

          {          

            _processRequest(instance); 

            Status.setStatusShow(false); 

            Request.showStatus=true;           

          } 

          else 

          { 

            Status.showInfo("您所请求的页面有异常，请检查！"); 

            window.setTimeout("Status.setStatusShow(false)",3000); 

          } 

        } 

      } 

    } 

    //_url加一个时刻改变的参数，防止由于被浏览器缓存后同样的请求不向服务器发送请求 

    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; 

      } 

    } 

  } 

   

  /** 

   * 间隔一段时间持续发送请求，只用于异步处理，只用于GET方式 

   * @param _interval:请求间隔，以毫秒计 

   * @param _url:请求地址 

   * @param _processRequest:用于处理返回结果的函数，其定义可以在别的地方，需要有一个参数，即要处理的通信对象 

   * @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) // 判断对象状态 

          { 

            if (instance.status == 200) // 信息已经成功返回，开始处理信息 

            { 

              _processRequest(instance); 

            } 

            else 

            { 

              Status.showInfo("您所请求的页面有异常，请检查！"); 

              window.setTimeout("Status.setStatusShow(false)",3000); 

            } 

          } 

        } 

      } 

      //_url加一个时刻改变的参数，防止由于被浏览器缓存后同样的请求不向服务器发送请求 

      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文件路径，若为相对路径，则是对应env.js的相对路径，也可以用绝对路径 

   * @param _language:对返回函数进行处理的语言，默认为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); 

    } 

  } 

   

  /** 

   * 该函数的效果是在应用它的script块后加一个script块 

   * 是由document.write在script块中的执行顺序决定的 

   */ 

  this.getJs=function(_jsName) 

  { 

    if (!Env.funcList[_jsName]) 

    { 

      Env.funcList[_jsName]="finished"; 

      document.write('<scr'+'ipt type="text/javascript" src="'+_jsName+'"></'+'scr'+'ipt>'); 

    } 

  } 

} 



/** 

 * ajax调用远程页面后，远程页面中script块未执行的处理 

 */ 

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); 

        } 

      } 

    } 

  } 

} 　　



需要引用别的js的时候，就加上如Env.require("cookie.js")，或Env.require("/common/cookie.js")，是用相对路径还是绝对路径就看喜好了，Env.require可用在页面模板中，也可用在js文件中，但一定要保证执行时env.js被显式引入。多次Env.require同一个js（不管用相对还是绝对），只有第一次会加载，所以不会重复。 



　　按个人应用不一样，可以修改一点，主体思想就这样了。