当前位置：Gxlcms > AJAX > 用ajax动态加载需要的js文件

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

时间：2021-07-01 10:21:17 帮助过：39人阅读

习惯了用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了

  1.  /** 
  2.  * @author zxub 2006-06-01 
  3.  * 状态信息显示类，用var Status=new function()定义，可以静态引用其中的方法 
  4.  * 一般情况下为function Status()，这样不能静态引用其中的方法，需要通过对象来引用 
  5.  */ 
  6. var Status=new function() 
  7. { 
  8.   this.statusDiv=null; 
  9.    
  10.   /** 
  11.    * 初始化状态显示层 
  12.    */ 
  13.   this.init=function() 
  14.   { 
  15.     if (this.statusDiv!=null) 
  16.     { 
  17.       return; 
  18.     } 
  19.     var body = document.getElementsByTagName("body")[0]; 
  20.     var div = document.createElement("div"); 
  21.     div.style.position = "absolute"; 
  22.     div.style.top = "50%"; 
  23.     div.style.left = "50%"; 
  24.     div.style.width = "280px"; 
  25.     div.style.margin = "-50px 0 0 -100px";     
  26.     div.style.padding = "15px"; 
  27.     div.style.backgroundColor = "#353555"; 
  28.     div.style.border = "1px solid #CFCFFF"; 
  29.     div.style.color = "#CFCFFF"; 
  30.     div.style.fontSize = "14px"; 
  31.     div.style.textAlign = "center"; 
  32.     div.id = "status"; 
  33.     body.appendChild(div); 
  34.     div.style.display="none"; 
  35.     this.statusDiv=document.getElementById("status"); 
  36.   } 
  37.    
  38.   /** 
  39.    * 设置状态信息 
  40.    * @param _message:要显示的信息 
  41.    */   
  42.   this.showInfo=function(_message) 
  43.   {    
  44.     if (this.statusDiv==null) 
  45.     { 
  46.       this.init(); 
  47.     }  
  48.     this.setStatusShow(true); 
  49.     this.statusDiv.innerHTML = _message;     
  50.   } 
  51.     
  52.   /** 
  53.    * 设置状态层是否显示 
  54.    * @param _show:boolean值，true为显示，false为不显示 
  55.    */  
  56.   this.setStatusShow=function(_show) 
  57.   {    
  58.     if (this.statusDiv==null) 
  59.     { 
  60.       this.init(); 
  61.     }  
  62.     if (_show) 
  63.     { 
  64.       this.statusDiv.style.display=""; 
  65.     } 
  66.     else 
  67.     { 
  68.       this.statusDiv.innerHTML=""; 
  69.       this.statusDiv.style.display="none"; 
  70.     } 
  71.   } 
  72. } 
  73. /** 
  74.  * @author zxub 
  75.  * 用于存放通道名称及通信对象的类，这样可以通过不同通道名称来区分不同的通信对象 
  76.  */ 
  77. function HttpRequestObject() 
  78. { 
  79.   this.chunnel=null; 
  80.   this.instance=null; 
  81. } 
  82. /** 
  83.  * @author zxub 
  84.  * 通信处理类，可以静态引用其中的方法 
  85.  */ 
  86. var Request=new function() 
  87. { 
  88.   this.showStatus=true; 
  89.    
  90.   //通信类的缓存 
  91.   this.httpRequestCache=new Array(); 
  92.    
  93.   /** 
  94.    * 创建新的通信对象 
  95.    * @return 一个新的通信对象 
  96.    */ 
  97.   this.createInstance=function() 
  98.   { 
  99.     var instance=null; 
  100.     if (window.XMLHttpRequest) 
  101.     { 
  102.       //mozilla 
  103.       instance=new XMLHttpRequest(); 
  104.       //有些版本的Mozilla浏览器处理服务器返回的未包含XML mime-type头部信息的内容时会出错。因此，要确保返回的内容包含text/xml信息 
  105.       if (instance.overrideMimeType) 
  106.       { 
  107.         instance.overrideMimeType="text/xml"; 
  108.       } 
  109.     } 
  110.     else if (window.ActiveXObject) 
  111.     { 
  112.       //IE 
  113.       var MSXML = ['MSXML2.XMLHTTP.5.0', 'Microsoft.XMLHTTP', 'MSXML2.XMLHTTP.4.0', 'MSXML2.XMLHTTP.3.0', 'MSXML2.XMLHTTP']; 
  114.       for(var i = 0; i < MSXML.length; i++) 
  115.       { 
  116.         try 
  117.         { 
  118.           instance = new ActiveXObject(MSXML[i]); 
  119.           break; 
  120.         } 
  121.         catch(e) 
  122.         {           
  123.         } 
  124.       } 
  125.     } 
  126.     return instance; 
  127.   } 
  128.    
  129.   /** 
  130.    * 获取一个通信对象 
  131.    * 若没指定通道名称，则默认通道名为"default" 
  132.    * 若缓存中不存在需要的通信类，则创建一个，同时放入通信类缓存中 
  133.    * @param _chunnel：通道名称，若不存在此参数，则默认为"default" 
  134.    * @return 一个通信对象，其存放于通信类缓存中 
  135.    */ 
  136.   this.getInstance=function(_chunnel) 
  137.   { 
  138.     var instance=null; 
  139.     var object=null; 
  140.     if (_chunnel==undefined)//没指定通道名称 
  141.     { 
  142.       _chunnel="default"; 
  143.     } 
  144.     var getOne=false; 
  145.     for(var i=0; i<this.httpRequestCache; i++) 
  146.     { 
  147.       object=HttpRequestObject(this.httpRequestCache[i]); 
  148.       if (object.chunnel==_chunnel) 
  149.       { 
  150.         if (object.instance.readyState==0 || object.instance.readyState==4) 
  151.         { 
  152.           instance=object.instance; 
  153.         } 
  154.         getOne=true; 
  155.         break;           
  156.       } 
  157.     } 
  158.     if (!getOne) //对象不在缓存中，则创建 
  159.     { 
  160.       object=new HttpRequestObject(); 
  161.       object.chunnel=_chunnel; 
  162.       object.instance=this.createInstance(); 
  163.       this.httpRequestCache.push(object); 
  164.       instance=object.instance; 
  165.     }      
  166.     return instance; 
  167.   } 
  168.    
  169.   /** 
  170.    * 客户端向服务端发送请求 
  171.    * @param _url:请求目的 
  172.    * @param _data:要发送的数据 
  173.    * @param _processRequest:用于处理返回结果的函数，其定义可以在别的地方，需要有一个参数，即要处理的通信对象 
  174.    * @param _chunnel:通道名称，默认为"default" 
  175.    * @param _asynchronous:是否异步处理，默认为true,即异步处理 
  176.    */ 
  177.   this.send=function(_url,_data,_processRequest,_chunnel,_asynchronous) 
  178.   { 
  179.     if (_url.length==0 || _url.indexOf("?")==0) 
  180.     { 
  181.       Status.showInfo("由于目的为空，请求失败，请检查！"); 
  182.       window.setTimeout("Status.setStatusShow(false)",3000); 
  183.       return; 
  184.     } 
  185.     if (this.showStatus) 
  186.     { 
  187.       Status.showInfo("请求处理中，请稍候");  
  188.     } 
  189.     if (_chunnel==undefined || _chunnel=="") 
  190.     { 
  191.       _chunnel="default"; 
  192.     } 
  193.     if (_asynchronous==undefined) 
  194.     { 
  195.       _asynchronous=true; 
  196.     } 
  197.     var instance=this.getInstance(_chunnel); 
  198.     if (instance==null) 
  199.     { 
  200.       Status.showInfo("浏览器不支持ajax，请检查！") 
  201.       window.setTimeout("Status.setStatusShow(false)",3000); 
  202.       return; 
  203.     }  
  204.     if (_asynchronous==true && typeof(_processRequest)=="function") 
  205.     { 
  206.       instance.onreadystatechange=function() 
  207.       { 
  208.         if (instance.readyState == 4) // 判断对象状态 
  209.         { 
  210.           if (instance.status == 200) // 信息已经成功返回，开始处理信息 
  211.           {          
  212.             _processRequest(instance); 
  213.             Status.setStatusShow(false); 
  214.             Request.showStatus=true;           
  215.           } 
  216.           else 
  217.           { 
  218.             Status.showInfo("您所请求的页面有异常，请检查！"); 
  219.             window.setTimeout("Status.setStatusShow(false)",3000); 
  220.           } 
  221.         } 
  222.       } 
  223.     } 
  224.     //_url加一个时刻改变的参数，防止由于被浏览器缓存后同样的请求不向服务器发送请求 
  225.     if (_url.indexOf("?")!=-1) 
  226.     { 
  227.       _url+="&requestTime="+(new Date()).getTime(); 
  228.     } 
  229.     else 
  230.     { 
  231.       _url+="?requestTime="+(new Date()).getTime(); 
  232.     } 
  233.     if (_data.length==0) 
  234.     { 
  235.       instance.open("GET",_url,_asynchronous);      
  236.       instance.send(null);       
  237.     } 
  238.     else 
  239.     { 
  240.       instance.open("POST",_url,_asynchronous); 
  241.       instance.setRequestHeader("Content-Length",_data.length); 
  242.       instance.setRequestHeader("Content-Type","application/x-www-form-urlencoded"); 
  243.       instance.send(_data); 
  244.     } 
  245.     if (_asynchronous==false && typeof(_processRequest)=="function") 
  246.     { 
  247.       _processRequest(instance); 
  248.       if (Request.showStatus) 
  249.       { 
  250.         Status.setStatusShow(false); 
  251.       } 
  252.       else 
  253.       { 
  254.         Request.showStatus=true; 
  255.       } 
  256.     } 
  257.   } 
  258.    
  259.   /** 
  260.    * 间隔一段时间持续发送请求，只用于异步处理，只用于GET方式 
  261.    * @param _interval:请求间隔，以毫秒计 
  262.    * @param _url:请求地址 
  263.    * @param _processRequest:用于处理返回结果的函数，其定义可以在别的地方，需要有一个参数，即要处理的通信对象 
  264.    * @param _chunnel:通道名称，默认为"defaultInterval"，非必添 
  265.    */ 
  266.   this.intervalSend=function(_interval,_url,_processRequest,_chunnel) 
  267.   { 
  268.     var action=function() 
  269.     { 
  270.       if (_chunnel==undefined) 
  271.       { 
  272.         _chunnel="defaultInterval"; 
  273.       } 
  274.       var instance=Request.getInstance(_chunnel); 
  275.       if (instance==null) 
  276.       { 
  277.         Status.showInfo("浏览器不支持ajax，请检查！") 
  278.         window.setTimeout("Status.setStatusShow(false)",3000); 
  279.         return; 
  280.       } 
  281.       if (typeof(_processRequest)=="function") 
  282.       { 
  283.         instance.onreadystatechange=function() 
  284.         { 
  285.           if (instance.readyState == 4) // 判断对象状态 
  286.           { 
  287.             if (instance.status == 200) // 信息已经成功返回，开始处理信息 
  288.             { 
  289.               _processRequest(instance); 
  290.             } 
  291.             else 
  292.             { 
  293.               Status.showInfo("您所请求的页面有异常，请检查！"); 
  294.               window.setTimeout("Status.setStatusShow(false)",3000); 
  295.             } 
  296.           } 
  297.         } 
  298.       } 
  299.       //_url加一个时刻改变的参数，防止由于被浏览器缓存后同样的请求不向服务器发送请求 
  300.       if (_url.indexOf("?")!=-1) 
  301.       { 
  302.         _url+="&requestTime="+(new Date()).getTime(); 
  303.       } 
  304.       else 
  305.       { 
  306.         _url+="?requestTime="+(new Date()).getTime(); 
  307.       } 
  308.       instance.open("GET",_url,true); 
  309.       instance.send(null); 
  310.     } 
  311.     window.setInterval(action,_interval);     
  312.   } 
  313. } 
  314. var Env=new function() 
  315. {   
  316.   this.funcList=new Array(); 
  317.      
  318.   this.envPath=null; 
  319.    
  320.   this.getPath=function() 
  321.   { 
  322.     this.envPath=document.location.pathname; 
  323.     this.envPath=this.envPath.substring(0,this.envPath.lastIndexOf("/")+1);     
  324.     var _scripts=document.getElementsByTagName("script"); 
  325.     var _envPath=null; 
  326.     var _scriptSrc=null; 
  327.     for (var i=0; i<_scripts.length; i++) 
  328.     { 
  329.       _scriptSrc=_scripts[i].getAttribute("src"); 
  330.       if (_scriptSrc && _scriptSrc.indexOf("env.js")!=-1) 
  331.       { 
  332.         break; 
  333.       } 
  334.     } 
  335.     if (_scriptSrc!=null) 
  336.     { 
  337.       if (_scriptSrc.charAt(0)=='/') 
  338.       { 
  339.         this.envPath=_scriptSrc.substr(0,_scriptSrc.length-6); 
  340.       } 
  341.       else 
  342.       { 
  343.         this.envPath=this.envPath+_scriptSrc.substr(0,_scriptSrc.length-6); 
  344.       } 
  345.     }     
  346.   } 
  347.   this.getPath();   
  348.    
  349.   /** 
  350.    * 按需获取需要的js文件 
  351.    * @param _jsName：js文件路径，若为相对路径，则是对应env.js的相对路径，也可以用绝对路径 
  352.    * @param _language:对返回函数进行处理的语言，默认为JScript，可不填 
  353.    */ 
  354.   this.require=function(_jsName,_language) 
  355.   { 
  356.     var _absJsName=null; 
  357.     if (_jsName.charAt(0)=='/') 
  358.     { 
  359.       _absJsName=_jsName; 
  360.     } 
  361.     else 
  362.     { 
  363.       _absJsName=this.envPath+_jsName; 
  364.     }     
  365.     if (!Env.funcList[_absJsName]) 
  366.     { 
  367.       Env.funcList[_absJsName]="finished";  
  368.       var processJs=function(_instance) 
  369.       { 
  370.         //为兼容firefox做判断 
  371.         if (_language!=undefined) 
  372.         { 
  373.           if (window.execScript) 
  374.           { 
  375.             window.execScript(_instance.responseText,_language); 
  376.           } 
  377.           else 
  378.           { 
  379.             window.eval(_instance.responseText,_language); 
  380.           }                     
  381.         } 
  382.         else 
  383.         { 
  384.           if (window.execScript) 
  385.           { 
  386.             window.execScript(_instance.responseText); 
  387.           } 
  388.           else 
  389.           { 
  390.             window.eval(_instance.responseText); 
  391.           }           
  392.         }         
  393.       } 
  394.       Request.showStatus=false; 
  395.       Request.send(_absJsName,"",processJs,"",false); 
  396.     } 
  397.   } 
  398.    
  399.   /** 
  400.    * 该函数的效果是在应用它的script块后加一个script块 
  401.    * 是由document.write在script块中的执行顺序决定的 
  402.    */ 
  403.   this.getJs=function(_jsName) 
  404.   { 
  405.     if (!Env.funcList[_jsName]) 
  406.     { 
  407.       Env.funcList[_jsName]="finished"; 
  408.       document.write('<scr'+'ipt type="text/javascript" src="'+_jsName+'"></'+'scr'+'ipt>'); 
  409.     } 
  410.   } 
  411. } 
  412. /** 
  413.  * ajax调用远程页面后，远程页面中script块未执行的处理 
  414.  */ 
  415. function reloadJs(_language) 
  416. { 
  417.   var _c=document.getElementsByTagName("SCRIPT"); 
  418.   for (var i=0;i<_c.length;i++) 
  419.   { 
  420.     if (_c[i].src) 
  421.     { 
  422.       var _s=document.createElement("script"); 
  423.       _s.type="text/javascript"; 
  424.       _s.src=_c[i].src; 
  425.       //为兼容firefox不用_c[0].insertAdjacentElement("beforeBegin",_s) 
  426.       _c[0].parentNode.insertBefore(_s,_c[0]);       
  427.       _c[i].parentNode.removeChild(_c[i]); 
  428.     } 
  429.     else if (_c[i].text) 
  430.     { 
  431.       if (_language!=undefined) 
  432.       { 
  433.         if (window.execScript) 
  434.         { 
  435.           window.execScript(_c[i].text,_language); 
  436.         } 
  437.         else 
  438.         { 
  439.           window.eval(_c[i].text,_language); 
  440.         } 
  441.       } 
  442.       else 
  443.       { 
  444.         if (window.execScript) 
  445.         { 
  446.           window.execScript(_c[i].text); 
  447.         } 
  448.         else 
  449.         { 
  450.           window.eval(_c[i].text); 
  451.         } 
  452.       } 
  453.     } 
  454.   } 
  455. } 　　

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

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

人气教程排行

本站所有资源全部来源于网络，若本站发布的内容侵害到您的隐私或者利益，请联系我们删除！