用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（不管用相對還是絕對），只有第一次會載入，所以不會重複。
　　按個人應用不一樣，可以修改一點，主體思想就這樣了。