前段时间，用了下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了
复制代码 代码如下:
/**
*@authorzxub2006-06-01
*状态信息显示类，用varStatus=newfunction()定义，可以静态引用其中的方法
*一般情况下为functionStatus()，这样不能静态引用其中的方法，需要通过对象来引用
*/
varStatus=newfunction()
{
this.statusDiv=null;
/**
*初始化状态显示层
*/
this.init=function()
{
if(this.statusDiv!=null)
{
return;
}
varbody=document.getElementsByTagName("body")[0];
vardiv=document.createElement("div");
div.style.position="absolute";
div.style.top="50%";
div.style.left="50%";
div.style.width="280px";
div.style.margin="-50px00-100px";
div.style.padding="15px";
div.style.backgroundColor="#353555";
div.style.border="1pxsolid#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";
}
}
}
/**
*@authorzxub
*用于存放通道名称及通信对象的类，这样可以通过不同通道名称来区分不同的通信对象
*/
functionHttpRequestObject()
{
this.chunnel=null;
this.instance=null;
}
/**
*@authorzxub
*通信处理类，可以静态引用其中的方法
*/
varRequest=newfunction()
{
this.showStatus=true;
//通信类的缓存
this.httpRequestCache=newArray();
/**
*创建新的通信对象
*@return一个新的通信对象
*/
this.createInstance=function()
{
varinstance=null;
if(window.XMLHttpRequest)
{
//mozilla
instance=newXMLHttpRequest();
//有些版本的Mozilla浏览器处理服务器返回的未包含XMLmime-type头部信息的内容时会出错。因此，要确保返回的内容包含text/xml信息
if(instance.overrideMimeType)
{
instance.overrideMimeType="text/xml";
}
}
elseif(window.ActiveXObject)
{
//IE
varMSXML=['MSXML2.XMLHTTP.5.0','Microsoft.XMLHTTP','MSXML2.XMLHTTP.4.0','MSXML2.XMLHTTP.3.0','MSXML2.XMLHTTP'];
for(vari=0;i
try
{
instance=newActiveXObject(MSXML[i]);
break;
}
catch(e)
{
}
}
}
returninstance;
}
/**
*获取一个通信对象
*若没指定通道名称，则默认通道名为"default"
*若缓存中不存在需要的通信类，则创建一个，同时放入通信类缓存中
*@param_chunnel：通道名称，若不存在此参数，则默认为"default"
*@return一个通信对象，其存放于通信类缓存中
*/
this.getInstance=function(_chunnel)
{
varinstance=null;
varobject=null;
if(_chunnel==undefined)//没指定通道名称
{
_chunnel="default";
}
vargetOne=false;
for(vari=0;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=newHttpRequestObject();
object.chunnel=_chunnel;
object.instance=this.createInstance();
this.httpRequestCache.push(object);
instance=object.instance;
}
returninstance;
}
/**
*客户端向服务端发送请求
*@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;
}
varinstance=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="+(newDate()).getTime();
}
else
{
_url+="?requestTime="+(newDate()).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)
{
varaction=function()
{
if(_chunnel==undefined)
{
_chunnel="defaultInterval";
}
varinstance=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="+(newDate()).getTime();
}
else
{
_url+="?requestTime="+(newDate()).getTime();
}
instance.open("GET",_url,true);
instance.send(null);
}
window.setInterval(action,_interval);
}
}
varEnv=newfunction()
{
this.funcList=newArray();
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(vari=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";
varprocessJs=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('
}
}
}
/**
*ajax调用远程页面后，远程页面中script块未执行的处理
*/
functionreloadJs(_language)
{
var_c=document.getElementsByTagName("SCRIPT");
for(vari=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]);
}
elseif(_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（不管用相对还是绝对），只有第一次会加载，所以不会重复。
按个人应用不一样，可以修改一点，主体思想就这样了。
