用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(不管用相对还是绝对),只有第一次会加载,所以不会重复。
  按个人应用不一样,可以修改一点,主体思想就这样了。

(0)

相关推荐

  • 使用PHP+AJAX让WordPress动态加载文章的教程

    为什么要动态加载文章? 1. 快速向访客展示页面 文章很容是包含大量文字和多媒体资源 (如: 图片, 视频, 音乐), 加载这些内容需要占用很多的时间. 如果你的页面上存在大量文章, 当访客发现页面久久没有加载完成就感到不耐烦. 这是动态加载文章的主要目的. 2. 让文章列表化 使页面上的文章成为一个列表, 减少页面的空间占用, 访客可以方便的移动到页面下方, 提高旧文章被点击的几率. 并且你可以在页面上放置更多的文章而不用担心页面过长. 为什么不动态加载文章? 1. 对搜索引擎不友好 搜索引擎

  • jQuery结合ajax实现动态加载文本内容

    ajax() 方法通过 HTTP 请求加载远程数据. 该方法是 jQuery 底层 AJAX 实现.简单易用的高层实现见 $.get, $.post 等.$.ajax() 返回其创建的 XMLHttpRequest 对象.大多数情况下你无需直接操作该函数,除非你需要操作不常用的选项,以获得更多的灵活性. 最简单的情况下,$.ajax() 可以不带任何参数直接使用. 通过 AJAX 加载一段文本: jQuery 代码: $(document).ready(function(){ $("#b01&q

  • AJAX和jQuery动态加载数据的实现方法

    什么是AJAX? 这里的AJAX不是希腊神话里的英雄,也不是清洁剂品牌,更不是一门语言,而是指异步Javascript和XML(Asynchronous JavaScript And XML),这里的XML(数据格式)也可以是纯文本(Plain Text)或是JSON.简单的说,就是使用XMLHttpRequest对象和服务器端交换数据(以XML或是JSON等格式),使用JavaScript处理数据并更新页面内容. 为什么要使用AJAX? 借助AJAX,我们可以实现: 在不重载页面的情况下,向服

  • 利用Dojo和JSON建立无限级AJAX动态加载的功能模块树

    看了"使用hibernate实现树形结构无限级分类"这篇文章后,我也想将自己在所有开发的项目中使用的功能模块树的实现方法以及完整DEMO(含源码)贴出来和大家分享.其实在我的博客里是老早贴出来的,由于时间关系没好好整理.        功能模块树是几乎在每个项目里都要用到的东西,利用Dojo的好处就是可以实现树的子节点的动态加载,这在树节点很多的情况下是很有用的.         下载附件二dojotree.rar,解压后将dist\dojotree.war部署到应用服务器即可浏览DE

  • php+ajax实现无刷新动态加载数据技术

    我们浏览有些网页的时候,当拉动浏览器的滚动条时到页底时,页面会继续自动加载更多内容供用户浏览.这种技术我暂且称它为滚屏加载技术.我们发现很多网站用到这种技术,必应图片搜索.新浪微博.QQ空间等将该技术应用得淋漓尽致. 滚屏加载技术,就是使用Javascript监视滚动条的位置,每次当滚动条到达浏览器窗口底部时,触发一个Ajax请求后台PHP程序,返回相应的数据,并将返回的数据追加到页面底部,从而实现了动态加载,其实就是一个典型的Ajax应用.本文将使用jQuery,结合PHP,mysql以及JS

  • 使用ajax+jqtransform实现动态加载select

    今天在工作的时候遇到一个问题,页面中公司名称是在项目名称选择后用ajax读取出来的.但是jqtransform是在页面加载完成后调用的,所以导致了公司名称下拉框无法展示最新的数据. <link rel="stylesheet" href="${ctx}/jqtransformplugin/jqtransform.css" type="text/css"></link> <script type="text/

  • Ajax动态加载数据库示例

    复制代码 代码如下: <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/1999/xhtml"> <head> <title></title

  • Ajax实现动态加载组合框的实例代码

    一  province.jsp <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%> <html> <head> <script type="text/javascript" language="javaScript"> var xmlHttp = false; //全局变量,

  • DataTables+BootStrap组合使用Ajax来获取数据并且动态加载dom的方法(排序,过滤,分页等)

    Datatables是一款jquery表格插件.它是一个高度灵活的工具,可以将任何HTML表格添加高级的交互功能. 主要功能 分页,即时搜索和排序 几乎支持任何数据源:DOM, javascript, Ajax 和 服务器处理 支持不同主题 DataTables, jQuery UI, Bootstrap, Foundation 各式各样的扩展: Editor, TableTools, FixedColumns -- 丰富多样的option和强大的API 支持国际化 超过2900+个单元测试 免

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

    习惯了用java,在java中,需要某个类直接import就可以了,所以做javascript的时候也想实现这个效果. 前段时间,用了下dojo,里面的dojo.require的功能很不错,一看代码,晕了,一大堆东西,唉-还是自己写个简单点的,dojo.require可以引入包,我就只做一个导入js文件的. 开始用的document.write,执行顺序不对了,这是在后面进行导入,而我们总是在前面执行中就需要导入的js,这样,执行中就会报"某某未定义",就是顺序问题了. 接着,我就想用

  • 如何实现JavaScript动态加载CSS和JS文件

    项目中需要用到动态加载CSS 文件,整理了一下,顺便融合了动态加载JS 的功能写成了一个对象,先上代码: var dynamicLoading = { css: function(path){ if(!path || path.length === 0){ throw new Error('argument "path" is required !'); } var head = document.getElementsByTagName('head')[0]; var link =

  • ajax动态加载json数据并详细解析

    效果图 jsp代码 <form > 姓名:<input name="name" type="text"/> 年龄:<input name="age" type="text"/> <input type="button" class="get" value="get提交"/> <input type="bu

  • AJAX 动态加载后台数据 绑定select的方法

    直接上代码 是可以用的,后台代码我就不贴了,我相信后台代码大家都会,直接返回json数据,我是前端比较差的,所以喜欢把每次不会的全部记起来 html代码 <select id="select" style="width : 80px;height : 30px;"> //下拉框数据动态加载 </select> js代码 $.ajax({ url: "", //后台webservice里的方法名称 contentType:

  • python爬取Ajax动态加载网页过程解析

    常见的反爬机制及处理方式 1.Headers反爬虫 :Cookie.Referer.User-Agent 解决方案: 通过F12获取headers,传给requests.get()方法 2.IP限制 :网站根据IP地址访问频率进行反爬,短时间内进制IP访问 解决方案: 1.构造自己IP代理池,每次访问随机选择代理,经常更新代理池 2.购买开放代理或私密代理IP 3.降低爬取的速度 3.User-Agent限制 :类似于IP限制 解决方案: 构造自己的User-Agent池,每次访问随机选择 5.

  • JavaScript 通过Ajax 动态加载CheckBox复选框

    废话不多说了,直接给大家贴代码了,具体代码如下所示: <pre name="code" class="html"> <div class="controls" id="compareyear"> </div></pre><br> <img src="http://img.blog.csdn.net/20170830165326131?watermark

  • JQuery Ajax动态加载Table数据的实例讲解

    我们在jsp定义一个select和一个table,要求实现根据select的选值,动态加载table数据. <select id="type" name="type" onchange="reloadTable(this)"></select> <table id="import-table" class="table table-striped table-bordered table

  • vue加载自定义的js文件方法

    在做项目中需要自定义弹出框.就自己写了一个. 效果图 遇见的问题 怎么加载自定义的js文件 vue-插件这必须要看.然后就是自己写了. export default{ install(Vue){ var tpl; // 弹出框 Vue.prototype.showAlter = (title,msg) =>{ var alterTpl = Vue.extend({ // 1.创建构造器,定义好提示信息的模板 template: '<div id="bg">' + '&

  • Java 动态加载jar和class文件实例解析

    本文研究的主要是Java 动态加载jar和class文件的相关内容,具体如下. JAVA中类文件加载是动态的.也就是说当我们用到的时候才会去加载,如果不用的话,就不会去加载我们的类. JAVA为我们提供了两种动态机制.第一种是隐式机制.第二种是显示机制.如下: 两种方法: 隐式机制 :new一个对象 + 调用类的静态方法 显式机制 :由 java.lang.Class的forName()方法加载 由 java.lang.ClassLoader的loadClass()方法加载 1.Class.fo

  • Yii2框架加载css和js文件的方法分析

    本文实例讲述了Yii2框架加载css和js文件的方法.分享给大家供大家参考,具体如下: 1.第一步是要把我们的css.js文件放到web目录下 2.第二步修改assets/AppAsset.php文件 <?php /** * @link http://www.yiiframework.com/ * @copyright Copyright (c) 2008 Yii Software LLC * @license http://www.yiiframework.com/license/ */ na

随机推荐