加载_文件加载 - CSDN
  • 如果需要编辑器载入图片,那图片所在站点的根目录下也要放置crossdomain.xml,例如图片url是http://t3.baidu.com/it/u=3205204196,1723632348&fm=24&gp=0.jpg,那...一般情况下百度是不会让您抓取的,所以要加载的图片
    如果需要编辑器载入图片,那图片所在站点的根目录下也要放置crossdomain.xml,例如图片url是http://t3.baidu.com/it/u=3205204196,1723632348&fm=24&gp=0.jpg,那crossdomain.xml的url就应该是http://t3.baidu.com/crossdomain.xml
    一般情况下百度是不会让您抓取的,所以要加载的图片还是要放在自己服务器上。
    如果crossdomain.xml已经按要求放置了还是不能加载图片,应检查下是否是防盗链情况导致无法加载图片
    展开全文
  • h5页面预加载资源

    2019-01-02 18:05:58
    因为不方便一一转载,我把链接放在下方...前端资源预加载并展示进度条 页面预加载loading动画,再载入内容 使用HTML5的页面资源预加载(Link prefetch)功能加速你的页面加载速度 H5前端性能优化之预加载知识  ...
    展开全文
  • java编译和类加载详述

    2018-11-21 19:44:37
    然后Java虚拟机将编译好的字节码文件加载到内存(这个过程被称为类加载,是由加载器完成的),然后虚拟机针对加载到内存的java类进行解释执行,显示结果。   Java的运行原理 在Java中引入了虚拟机的概念,即在...

    Java程序运行时,必须经过编译和运行两个步骤。首先将后缀名为.java的源文件进行编译,最终生成后缀名为.class的字节码文件。然后Java虚拟机将编译好的字节码文件加载到内存(这个过程被称为类加载,是由加载器完成的),然后虚拟机针对加载到内存的java类进行解释执行,显示结果。

     

    Java的运行原理

    在Java中引入了虚拟机的概念,即在机器和编译程序之间加入了一层抽象的虚拟的机器。这台虚拟的机器在任何平台上都提供给编译程序一个的共同的接口。编译程序只需要面向虚拟机,生成虚拟机能够理解的代码然后由解释器来将虚拟机代码转换为特定系统的机器码执行。在Java中,这种供虚拟机理解的代码叫做字节码(ByteCode),它不面向任何特定的处理器,只面向虚拟机。每一种平台的解释器是不同的,但是实现的虚拟机是相同的。Java源程序经过编译器编译后变成字节码,字节码由虚拟机解释执行,虚拟机将每一条要执行的字节码送给解释器,解释器将其翻译成特定机器上的机器码,然后在特定的机器上运行。

     

    Java代码编译整个过程

    Java代码编译是由Java源码编译器来完成,流程图如下所示:

    javaç¨åºçæ§è¡è¿ç¨è¯¦è§£

    词法分析器:

    词法分析器一般以函数的形式存在,供语法分析器调用。

    这里的单词是一个字符串,是构成源代码的最小单位。从输入字符流中生成单词的过程叫作单词化(Tokenization),在这个过程中,词法分析器还会对单词进行分类。

    词法分析器通常不会关心单词之间的关系(属于语法分析的范畴),举例来说:词法分析器能够将括号识别为单词,但并不保证括号是否匹配。

    词法分析(lexical analysis)或扫描(scanning)是编译器的第一个步骤。词法分析器读入组成源程序的字符流,并且将它们组织成有意义的词素(lexeme)的序列,并对每个词素产生词法单元(token)作为输出。

    简单的来说,词法分析就是将源程序(可以认为是一个很长的字符串)读进来,并且“切”成小段(每一段就是一个词法单元 token),每个单元都是有具体的意义的,例如表示某个特定的关键词,或者代表一个数字。而这个词法单元在源程序中对应的文本,就叫做“词素”。词法分析注重的是每个单词是否合法,以及这个单词属于语言中的哪些部分

    token流:词法分析器的结果,就是把程序的语句进行分词得到的的一个个“单词”!

    语法分析器:

    是对token流进行语法检查、并构建由输入的单词组成的数据结构(语法树/抽象语法树)。语法分析器通常使用一个独立的词法分析器从输入字符流中分离出一个个的“单词”;语法分析的上下文无关文法注重的是一个一个的推导式,是将词法分析中得到的单词按照语法规则进行组合 

    语法树/抽象语法树:

    源代码的抽象语法结构的树状表现形式,这里特指java的源代码。树上的每个节点都表示源代码中的一种结构。之所以说语法是“抽象”的,是因为这里的语法并不会表示出真实语法中出现的每个细节。比如,嵌套括号被隐含在树的结构中,并没有以节点的形式呈现;而类似于if(;;){ //当符合条件执行的任务}或者 while(true){//当符合条件执行的任务}这样的条件跳转语句,可以使用带有两个分支的节点来表示。

    语义分析器:语义分析就是要了解各个推导式之间的关系是否合法,主要体现在推导式中使用的终结符和非终结符之间的关系,也就是它们的类型。

    注解抽象语法树:经过 语义分析器将语法树/抽象语法树转化为注解抽象语法树

     

    字节码生成:

    目的:将注解语法树转化成字节码,并将字节码写入*.class文件。

    流程:

    • 将java的代码块转化为符合JVM语法的命令形式,这就是字节码
    • 按照JVM的文件组织格式将字节码输出到*.class文件中

     

    类加载详解:

    在Java 中分为主动引用和被动引用 主动引用都会触发类的加载!比如:访问这个类的静态变量,方法,和 通过new ,jvm标记加载的类(存在main方法的类),反射等,父类在子类加载的时候也会被加载

    被动引用:比如访问静态常量或者创建数组内部对象

    类加载主要是由jvm虚拟机负责的,过程非常复杂,类加载分三步  加载   》  连接  》初始化

    加载

    程序运行之前jvm会把编译完成的.class二进制文件加载到内存,供程序使用,用到的就是类加载器classLoader ,java程序的运行并不是直接依   靠底层的操作系统,而是基于jvm虚拟机。

    类加载器:负责读取字节码,并转换成java.Long.Class类的一个对象存在于方法区

    加载阶段与连接阶段的部分内容(如一部分字节码文件格式验证动作)是交叉进行的,加载阶段尚未完成,连接阶段可能已经开始

    注意:要判断两个类是否“相同”,前提是这两个类必须被同一个类加载器加载,否则这个两个类不“相同”。
    这里指的“相同”,包括类的Class对象的equals()方法、isAssignableFrom()方法、isInstance()方法、instanceof关键字等判断出来的结果。

    java中加载器的种类大致可以分为四种:

    1.Bootstrap ClassLoader(由C++语言写成)顶级加载器,%JAVA_HOME%/jre/lib,-Xbootclasspath参数指定的路径以及%JAVA_HOME%/jre/classes中的类。

    2.系统加载器(也就是内部类AppClassLoader)   加载classpath下的路径下的class

    3.ExtClassLoader,加载jre\lib\ext\classes文件下的class

    4.java.net.UrlClassLoader. 加载指定的url下的class


    当我们运行一个程序时,首先是找到JDK安装目下的jvm.dll来启动JAVA虚拟机。

    而后Bootstrap ClassLoader产生。

    接下来就是Bootstrap ClassLoader来加载ExtClassLoader,并且指定ExtClassLoader的父加载器为Bootstrap ClassLoader,但是因为Bootstrap ClassLoader用C++语言写的,所以用JAVA的观点来看,这个加载器的实例是不存在的所以ExtClassLoader的父加载器被设置为了null。

    然后就是Bootstrap ClassLoader将AppClassLoader装载,并指定其父加载器为ExtClassLoader。

    双亲委派模型:是通过组合实现的!并不是继承关系!


    JAVA是按照加载器的委派模型来实现的。这种模型是JAVA安全性机制的保证。

    如果一个类加载器收到了类加载请求,它并不会自己先去加载,而是把这个请求委托给父类的加载器去执行,如果父类加载器还存在其父类加载器,则进一步向上委托,依次递归,请求最终将到达顶层的启动类加载器,如果父类加载器可以完成类加载任务,就成功返回,倘若父类加载器无法完成此加载任务,子加载器才会尝试自己去加载,这就是双亲委派模式,即每个儿子都不愿意干活,每次有活就丢给父亲去干,直到父亲说这件事我也干不了时,儿子自己想办法去完成,这不就是传说中的双亲委派模式。

     采用双亲委派模式的是好处是Java类随着它的类加载器一起具备了一种带有优先级的层次关系,通过这种层级关可以避免类的重复加载,当父亲已经加载了该类时,就没有必要子ClassLoader再加载一次。其次是考虑到安全因素,可以防止核心API库被随意篡改

     

     

    连接

           连接是很重要的一步,过程比较复杂,分为三步  验证  》准备  》解析    

      验证:确保类加载的正确性。一般情况由javac编译的class文件是不会有问题的,但是可能有人的class文件是自己通过其他方式编译出来的,这就很有可能不符合jvm的编译规则,这一步就是要过滤掉这部分不合法文件 

      准备:为类的静态变量分配内存,将其初始化为默认值 。我们都知道静态变量是可以不用我们手动赋值的,它自然会有一个初始值 比如int 类型的初始值就是0 ;boolean类型初始值为false,引用类型的初始值为null 。 这里注意,只是为静态变量分配内存,此时是没有对象实例的 

      解析:将class 内的 符号引用,加载到 运行时常量池 内转化成为 直接引用 的过程解释一下符号引用和直接引用。比如在方法A中使用方法B,A(){B();},这里的B()就是符号引用,它对于方法的调用没有太多的实际意义。但是B方法实际调用时是通过一个指针指向B方法的内存地址,这个指针才是真正负责方法调用,他就是直接引用。

    初始化

    为类的静态变量赋予正确的初始值,上述的准备阶段为静态变量赋予的是虚拟机默认的初始值,此处赋予的才是程序编写者为变量分配的真正的初始值

    类加载完成!!!

    备注:

    当 JVM 遇到 new 指令时,首先去检查这个指令的参数能否在常量池中定位到一个类的符号引用,并且检查这个符号引用代表的类是否已经被加载过,如果没有就先执行类加载。如果类已经被加载过,则会为新生对象分配内存(所需内存大小在类加载后就可以确定),分配对象内存采取的方式是“指针碰撞”或“空闲列表”,前者是在内存比较规整的情况下,后者是在空闲内存和已使用内存相互交错的情况下,而内存是否规整这又取决于垃圾回收器。

    问:我们通过 Java 栈中对象的引用去访问这个对象,访问对象的主流方式有 那些

    答 :使用句柄和直接指针。

    使用句柄访问:在 Java 堆中会划分出一块内存作为句柄池,引用中储存的内容就是对象的句柄地址,而句柄中包含了对象实例数据与类型数据各自的具体地址信息。

    直接指针访问:在对象的内存布局中就要放置访问类型数据的指针。

    这两种方式各有优势,使用句柄的好处是引用中存储的是稳定的句柄,对象被移动时(垃圾回收时对象被移动)只需改变句柄中的实例数据的指针,不需要改动引用本身。而使用直接指针的好处是速度更快,它节省了一次指针定位的开销。HotSpot 使用的是第二种方式进行对象的访问。

    问:怎解决内存分配的线程安全问题?

    答:jvm提供了2种解决内存分配的线程安全问题,1.使用cas无锁机制失败重试来保证操作的原子性 2.jvm 会给每条线程分配本地线程分配缓冲TLAB 可以通过配置来决定分配的大小,只有当分配内存用完后才会去锁进行同步操作

     

     

     

     

     

     

     

     

     

     

    展开全文
  • 加载和预加载的实现提到前端性能优化中图片资源的优化,懒加载和预加载就不能不说,下面我用最简洁明了的语言说明懒加载和预加载的核心要点以及实现懒加载什么是懒加载加载也就是延迟加载; 当访问一个页面时,先将...

    懒加载和预加载的实现

    提到前端性能优化中图片资源的优化,懒加载和预加载就不能不说,下面我用最简洁明了的语言说明懒加载和预加载的核心要点以及实现

    懒加载

    什么是懒加载

    懒加载也就是延迟加载; 当访问一个页面时,先将img标签中的src链接设为同一张图片(这样就只需请求一次,俗称占位图), 将其真正的图片地址存储在img标签的自定义属性中(比如data-src); 当js监听到该图片元素进入可视窗口时,即将自定义属性中的地址存储到src属性中,达到懒加载的效果; 这样做能防止页面一次性向服务器响应大量请求导致服务器响应慢页面卡顿或崩溃等问题

    为什么要使用懒加载

    懒加载对于图片较多页面很长的业务场景很适用,可以减少无效资源的加载

    懒加载的实现步骤

    1. 首先,不要将图片地址放到src属性中,而是放到其它属性(data-src)中

    2. 页面加载完成后,根据scrollTop判断图片是否在用户的视野内, 如果在,则将data-original属性中的值取出存放到src属性中

    3. 在滚动事件中重复判断图片是否进入视野; 如果进入,则将data-original属性中的值取出存放到src属性中

    代码实现

    既然懒加载的原理是基于判断元素是否出现在窗口可视范围内, 首先我们写一个函数判断元素是否出现在可视范围内:

    <script>
    function isVisible($node){
        var winH = $(window).height(),
            scrollTop = $(window).scrollTop(),
            offSetTop = $(window).offSet().top;
        if (offSetTop < winH + scrollTop) {
            return true;
        } else {
            return false;
        }
    }
    </script>
    

    再添加上浏览器的事件监听函数,让浏览器每次滚动就检查元素是否出现在窗口可视范围内:

    <script>
    $(window).on("scroll", function{
        if (isVisible($node)){
            console.log(true);
        }
    })
    </script>
    

    现在我们要做的是,让元素只在第一次被检查到时打印true,之后就不再打印了

    <script>
    var hasShowed = false;
    $(window).on("sroll",function{
        if (hasShowed) {
            return;
        } else {
            if (isVisible($node)) {
                hasShowed = !hasShowed;
                console.log(true);
            }
        }
    })
    </script>
    

    这样我们就实现了懒加载

    利用懒加载和AJAX,我们还可以实现无限滚动查看时间线/ 在滚动页面一段距离后出现回到顶部按钮的效果

    懒加载的优点

    显著的提高页面加载速度,又不下载多余的资源节省了流量; 同时更少的图片并发请求数也可以减轻服务器的压力

    懒加载插件

    关于图片延时加载,网上有很多应用的例子以及插件; 目前研究过的两个插件分别是jquery插件lazyload.js和原生js插件echo.js; 二者的区别不用说,jquery插件使用的时候必须引入jquery才可以,且该插件功能强大,灵活性也高; 而echo.js是用原生写的插件,代码少,不依赖其他库,拿起来就可以用, 但能够实现的效果不如lazyload丰富强大,但基本的延时加载要求都能满足

    jquery.lazyload.js

    如何使用

    延迟加载依赖于于jQuery,第一步引入文件:

    <script src ="jQuery.js"></script>
    <script src="jQuery.lazyload.js"></script>
    

    接下来修改html的一些属性:图像的src地址暂时存储在自定义属性data-original中, 然后给需要延时加载图像加上一个特定的类,类的名字由你自己决定, 使用的时候统一类名即可;为这些图片绑定延时加载:

    <img class="lazy" src="img/grey.gif" data-original="img/example.jpg"  width="640" heigh="480">
    

    用的时候就像下面:

    $("img.lazy").lazyload();
    

    所有class为lazy的图片将被延迟加载

    注意:必须设置图像的尺寸,宽度和高度属性或CSS,否则插件可能无法正常工作

    参数设置

    1.设置阈值

    默认情况下图片在位于可视区域后才开始加载; 如果想提前加载图片,可通过设置threshold的值来改变其显示的时间, 设置threshold为200使图片在距离屏幕可见区域下方200像素时就开始加载

    $("img.lazy").lazyload({
      threshold:200
    });
    

    2.事件触发加载

    默认是scoll事件触发延时加载, 即等到用户向下滚动至图片出现在屏幕可视区域时图片才能加载, 但可以使用jQueryclick或mouseover等事件触发图片的加载, 也可以使用自定义事件, 实现只有当用户点击图片图片才能够加载时可以这样写:

    $("img.lazy").lazyload({
        event : "click"
    });
    

    注意:你也可以使用这个技巧延迟图片加载,即加载前延迟5秒后再加载图片; 就像下面这样(trigger()方法触发被选元素的指定事件类型):

    $(function() {
        $("img.lazy").lazyload({
            event:"click"
        });
    });
    $(window).bind("load", function() {
        var timeout = setTimeout(function() {
            $("img.lazy").trigger("click") //trigger()方法触发被选元素的指定事件类型
        }, 5000);
    });
    

    3.使用特殊效果加载图片

    插件默认使用show()方法显示图片;当然你可以使用任何你想用的特效来处理,例如使用fadeIn效果:  

    $("img.lazy").lazyload({ 
        effect : "fadeIn" //.effect()方法对一个元素应用了一个命名的动画 特效
    });
    

    4.为非JavaScript浏览器回退

    <img class="lazy" src="img/grey.gif" data-original="img/example.jpg"  width="640" heigh="480">
    <noscript><img src="img/example.jpg" width="640" heigh="480"></noscript>
    

    可以通过CSS隐藏占位符

    .lazy {
      display: none;
    }
    

    在支持JavaScript的浏览器中必须在DOM ready时将占位符显示出来,这可以在插件初始化的同时完成

    $("img.lazy").show().lazyload();
    

    这些都是可选的,但如果你希望插件平稳降级这些都是应该做的

    5.图片内容器

    可以将插件用在可滚动容器的图片上,例如带滚动条的DIV元素; 将容器定义为jQuery对象并作为参数传到初始化方法里面

    #container {
        height: 600px;
        overflow: scroll;
    }
    
    $("img.lazy").lazyload({         
         container: $("#container")
    }); 
    

    6.当图像并不是连续的

    滚动页面时,Lazy Load会循环加载图片; 在循环中检测图片是否在可视区域内,默认情况下在找到第一张不在可见区域的图片时停止循环; 图片被认为是流式分布的,图片在页面中的次序和HTML代码中次序相同; 但是在一些布局中,这样的假设是不成立的; 不过你可以通过failurelimit选项来控制加载行为

    $("img.lazy").lazyload({ 
        failure_limit : 10
    }); 
    

    将failurelimit设为10令插件找到10个不在可见区域的图片是才停止搜索

    7.处理看不见图像

    可能在你的页面上有很多隐藏的图片; 为了提升性能,Lazy Load默认忽略了隐藏图片; 如果想要加载隐藏图片,将skip_invisible设为 false:

    $("img.lazy").lazyload({ 
        skip_invisible : false
    }); 
    

    echo.js

    兼容性:Echo.js使用了HTML5的date属性,并且需要获取该属性的值,所以它并不兼容IE6/IE7

    使用方法:

    引入文件

    <script src="js/echo.min.js"></script> 
    

    HTML

    <img src="images/blank.gif" alt="pic" data-echo="img/pic.jpg" width="640" height="480">
    

    blank.gif用做默认图片,data-echo的属性值是图片的真实地址,同样最好给图片设置宽度和高度

    JavaScript

    echo.init({
        offset: 0,
        throttle: 0
    });
    

    参数说明

    echo.js只有两个参数:offset和throttle

    offset:设置图片在离可视区域下方在一定距离后开始被加载

    throttle:设置图片延迟多少毫秒后加载

    那么上面的代码的意思就是一旦图片进入可视区域就立即加载

    怎么样,使用起来真的很简单吧

    预加载

    什么是预加载

    提前加载图片,当用户需要查看时可直接从本地缓存中渲染

    为什么要使用预加载

    图片预先加载到浏览器中,访问者可顺利地在网站上冲浪,并享受到极快的加载速度; 这对图片占据很大比例的网站来说十分有利,保证了图片快速/无缝地发布, 也可帮助用户在浏览网站内容时获得更好的用户体验

    预加载的核心要点如下:

    图片等静态资源在使用前提前请求; 资源后续使用时可以从缓存中加载,提升用户体验; 页面展示的依赖关系维护(必需的资源加载完才可以展示页面,防止白屏等)

    实现预加载主要有三个方法:

    用CSS和JavaScript实现预加载

    实现预加载图片有很多方法,包括使用CSS/JavaScript/两者的各种组合, 这些技术可根据不同设计场景设计出相应的解决方案,十分高效

    1.单纯使用CSS,可容易/高效地预加载图片,代码如下:

    #preload-01 { background: url(http://domain.tld/image-01.png) no-repeat -9999px -9999px; }  
    #preload-02 { background: url(http://domain.tld/image-02.png) no-repeat -9999px -9999px; }  
    #preload-03 { background: url(http://domain.tld/image-03.png) no-repeat -9999px -9999px; }
    

    将这三个ID选择器应用到(X)HTML元素中, 我们便可通过CSS的background属性将图片预加载到屏幕外的背景上; 只要这些图片的路径保持不变,当它们在Web页面的其他地方被调用时, 浏览器就会在渲染过程中使用预加载(缓存)的图片;简单/高效,不需要任何JavaScript

    该方法虽然高效,但仍有改进余地; 使用该法加载的图片会同页面的其他内容一起加载, 增加了页面的整体加载时间;

    为了解决这个问题,我们增加了JS代码来推迟预加载的时间,直到页面加载完毕;代码如下:

    function preloader() {  
        if (document.getElementById) {  
            document.getElementById("preload-01").style.background = 
                    "url(http://domain.tld/image-01.png) no-repeat -9999px -9999px";  
            document.getElementById("preload-02").style.background = 
                    "url(http://domain.tld/image-02.png) no-repeat -9999px -9999px";  
            document.getElementById("preload-03").style.background = 
                    "url(http://domain.tld/image-03.png) no-repeat -9999px -9999px";  
        }  
    }  
    function addLoadEvent(func) {  
        var oldonload = window.onload;  
        if (typeof window.onload != 'function') {  
            window.onload = func;  
        } else {  
            window.onload = function() {  
                if (oldonload) {  
                    oldonload();  
                }  
                func();  
            }  
        }  
    }  
    
    addLoadEvent(preloader);
    

    在脚本的第一部分,我们获取使用类选择器的元素并为其设置了background属性,以预加载不同的图片; 脚本的第二部分,我们使用addLoadEvent()函数来延迟preloader()函数的加载时间,直到页面加载完毕; 如果JavaScript无法在用户的浏览器中正常运行,会发生什么? 很简单,图片不会被预加载,当页面调用图片时,正常显示即可

    2.仅使用JavaScript实现预加载

    上述方法有时确实很高效,但我们逐渐发现它在实际实现过程中会耗费太多时间; 相反,我更喜欢使用纯JavaScript来实现图片的预加载; 下面将提供两种这样的预加载方法,它们可以很漂亮地工作于所有现代浏览器之上

    加载方法1:

    只需简单编辑/加载所需要图片的路径与名称即可,很容易实现:

    <div class="hidden">  
        <script type="text/javascript">   
                var images = new Array()  
                function preload() {  
                    for (i = 0; i < preload.arguments.length; i++) {  
                        images[i] = new Image()  
                        images[i].src = preload.arguments[i]  
                    }  
                }  
                preload(  
                    "http://domain.tld/gallery/image-001.jpg",  
                    "http://domain.tld/gallery/image-002.jpg",  
                    "http://domain.tld/gallery/image-003.jpg"  
                )  
        </script>  
    </div>
    

    该方法尤其适用预加载大量的图片

    加载方法2:

    该方法与上面的方法类似,也可以预加载任意数量的图片;将下面的脚本添加入任何Web页中,根据程序指令进行编辑即可

    <div class="hidden">  
        <script type="text/javascript"> 
                if (document.images) {  
                    img1 = new Image();  
                    img2 = new Image();  
                    img3 = new Image();  
                    img1.src = "http://domain.tld/path/to/image-001.gif";  
                    img2.src = "http://domain.tld/path/to/image-002.gif";  
                    img3.src = "http://domain.tld/path/to/image-003.gif";  
                }  
        </script>  
    </div>
    

    正如所见,每加载一个图片都需要创建一个变量,如"img1=new Image();", 及图片源地址声明,如"img3.src='../path/to/image-003.gif';"; 参考该模式,可根据需要加载任意多的图片; 我们又对该方法进行了改进,将该脚本封装入一个函数中, 并使用addLoadEvent()延迟预加载时间,直到页面加载完毕

    function preloader() {  
        if (document.images) {  
            var img1 = new Image();  
            var img2 = new Image();  
            var img3 = new Image();  
            img1.src = "http://domain.tld/path/to/image-001.gif";  
            img2.src = "http://domain.tld/path/to/image-002.gif";  
            img3.src = "http://domain.tld/path/to/image-003.gif";  
        }  
    }  
    function addLoadEvent(func) {  
        var oldonload = window.onload;  
        if (typeof window.onload != 'function') {  
            window.onload = func;  
        } else {  
            window.onload = function() {  
                if (oldonload) {  
                    oldonload();  
                }  
                func();  
            }  
        }  
    }  
    addLoadEvent(preloader);
    

    3.使用Ajax实现预加载

    上面所给出的方法似乎不够酷,那现在来看一个使用Ajax实现图片预加载的方法; 该方法利用DOM,不仅仅预加载图片,还会预加载CSS/JavaScript等相关的东西; 使用Ajax比直接使用JavaScript优越之处在于JavaScript和CSS的加载不会影响到当前页面; 该方法简洁/高效

    window.onload = function() {  
        setTimeout(function() {  
            // XHR to request a JS and a CSS  
            var xhr = new XMLHttpRequest();  
            xhr.open('GET', 'http://domain.tld/preload.js');  
            xhr.send('');  
            xhr = new XMLHttpRequest();  
            xhr.open('GET', 'http://domain.tld/preload.css');  
            xhr.send('');  
            // preload image  
            new Image().src = "http://domain.tld/preload.png";  
        }, 1000);  
    };
    

    上面代码预加载了preload.js/preload.css/preload.png ,1000毫秒的超时是为了防止脚本挂起,而导致正常页面出现功能问题; 下面我们看看如何用JavaScript来实现该加载过程:

    window.onload = function() {   
        setTimeout(function() {   
            // reference to <head>  
            var head = document.getElementsByTagName('head')[0];   
            // a new CSS  
            var css = document.createElement('link');  
            css.type = "text/css";  
            css.rel  = "stylesheet";  
            css.href = "http://domain.tld/preload.css";   
            // a new JS  
            var js  = document.createElement("script");  
            js.type = "text/javascript";  
            js.src  = "http://domain.tld/preload.js";    
            // preload JS and CSS  
            head.appendChild(css);  
            head.appendChild(js);    
            // preload image  
            new Image().src = "http://domain.tld/preload.png";    
        }, 1000);    
    };
    

    这里,我们通过DOM创建三个元素来实现三个文件的预加载; 正如上面提到的那样,使用Ajax加载文件不会应用到加载页面上; 从这点上看,Ajax方法优越于JavaScript

    补充知识

    屏幕可视窗口大小

    <script>
      //原生方法
      window.innerHeight || //标准浏览器及IE9+
      document.documentElement.clientHeight || //标准浏览器及低版本IE标准模式
      document.body.clientHeight  //低版本混杂模式
      //jQuery方法 
      $(window).height();
    </script>
    

    滚动条滚动的距离

    <script>
      //原生方法
      window.pagYoffset || //标准浏览器及IE9+
      document.documentElement.scrollTop || //兼容ie低版本的标准模式
      document.body.scrollTop //兼容混杂模式;
      //jQuery方法 
      $(document).scrollTop();
    </script>
    

    获取元素的尺寸

    <script>
      $(o).width() = o.style.width;
      $(o).innerWidth() = o.style.width+o.style.padding;
      $(o).outerWidth() = o.offsetWidth = o.style.width+o.style.padding+o.style.border;
      $(o).outerWidth(true) = o.style.width+o.style.padding+o.style.border+o.style.margin;
    </script>
    

    注意:

    要使用原生的style.xxx方法获取属性,这个元素必须已经有内嵌的样式,如<div style="...."></div>;

    如果原先是通过外部或内部样式表定义css样式,必须使用 o.currentStyle[xxx] || document.defaultView.getComputedStyle(0)[xxx]来获取样式值

    获取元素的位置信息

    <script>
      //原生方法
      getoffsetTop();
      //jQuery方法 
      $(o).offset().top //元素距离文档顶的距离
      $(o).offset().left //元素距离文档左边缘的距离
      // 顺便提一下返回元素相对于第一个以定位的父元素的偏移距离,注意与上面偏移距的区别;
      jQuery:position() //返回一个对象
      $(o).position().left = o.style.left;
      $(o).position().top = o.style.top;
    </script>
    展开全文
  • 页面加载时loading效果

    2018-08-12 20:19:39
    &lt;!DOCTYPE html&gt; &lt;html lang="en"&gt; &lt;head&gt; &lt;meta charset="UTF-8"&gt; &lt;style&gt; #loading{position:fixed;...z-inde
  • 网页加载过程中提示“载入中…”,特别是使用动画效果,可以一个“等待”的温馨提示,用户体验很不错。下面介绍几种方法。 第一种:  原理就是,在网页载入时在页面最中间打入一个层上面显示,"网页正在载入中...
  • JS三种加载方式

    2019-02-28 15:49:32
    JS三种加载方式三种加载方式图解 三种加载方式图解
  • 加载加载”是”类加载”过程的一个阶段。在加载阶段,虚拟机需要完成以下3件事情:1.通过一个类的全限定名来获取定义此类的二进制字节流。 2.将这个字节流所代表的静态存储结构转化为方法区的运行时数据结构。 3....
  • 加载的三种方式

    2018-07-27 22:52:22
    加载分为动态加载和静态加载。动态加载是从外存储器中加载类,一般类加载机制分析的也是动态加载。而静态加载本质上是从内存中创建类的实例对象,此时类已经被加载到内存中。 一.静态加载 1. 通过new关键字来...
  • js一加载就执行

    2019-04-24 10:40:36
    Jquery中$(document).ready()的作用类似于... $(document).ready()是DOM结构绘制完毕后就执行,不必等到加载完毕,document.ready()加载的速度较快,只需要等待dom树的加载,无需等待图片以及媒体资源。 而window...
  • 本文介绍了懒加载,预加载的实现方法以及对比
  • 上拉加载(分页加载)   当用户打开一个页面时,假设后台数据量庞大时,一次性地返回所有数据给客户端,页面的打开速度就会有所下降,而且用户只看上面的内容而不需要看后面的内容时,也浪费用户流量,基于优化的...
  • 聊一聊JVM的类加载器机制 目录 聊一聊JVM的类加载器机制 01 怎么获取类加载器?哪几种类加载器 02 各个加载加载的路径? 01 怎么获取类加载器?哪几种类加载器 BootStrapClassLoader 引导类加载器 ...
  • 一个.java文件在编译后会形成相应的一个或多个Class文件,这些Class文件中描述的类的各种信息,最终都需要加载到虚拟机中之后才能被运行和使用。事实上,虚拟机把描述类的数据从Class文件加载到内存,并对数据进行...
  • Java的类加载机制是java技术体系中比较核心的部分,虽然和大部分开发人员直接打交道不多,但是对其背后的机理有一定理解有助于排查程序中出现的类加载失败等技术问题,对理解java虚拟机的连接模型和java语言的动态性
  • 然而,有一个很让人头疼的问题就是,我们去加载数据的时候由于ViewPager的内部机制所限制,所以它会默认至少预加载一个。这让人很郁闷,所以,我就想到要封装一个Fragment来解决这个问题。 这里还解决一个问题就是在...
  • 当程序主动使用某个类时,如果该类还未被加载到内存中,则JVM会通过加载、连接、初始化3个步骤来对该类进行初始化。如果没有意外,JVM将会连续完成3个步骤,所以有时也把这个3个步骤统称为类加载或类初始化。 一...
  • 类从被加载到虚拟机内存中开始,到卸载出内存为止,它的整个生命周期包括:加载、验证、准备、解析、初始化、使用和卸载七个阶段。 其中类加载的过程包括了加载、验证、准备、解析、初始化五个阶段。在这五个阶段...
  • 默认情况下如果网站请求速度慢,所以会有一段时间的空白页面等等,用户体验效果不好,见到很多的页面都有预加载的效果,加载之前先加载一个动画,后台进程继续加载页面内容,当页面内容加载完之后再退出动画显示内容...
  • 本文同步发表于我的微信公众号,扫一扫文章底部的二维码或在微信搜索 郭霖 即可关注,...现在Android上的图片加载框架非常成熟,从最早的老牌图片加载框架UniversalImageLoader,到后来Google推出的Volley,再到后
1 2 3 4 5 ... 20
收藏数 2,928,829
精华内容 1,171,531
关键字:

加载