jquery实现图片延时加载插件【多处】

  1 /***

  2 ****@link:图片预加载(懒加载)jquery插件版

  3 ****@author:linfusheng(改写网摘)

  4 ****@time:2013-04-16

  5 ****@调用方法:html格式为"<img height="300" width="960" src="" data-original="1.jpg" />";

  6 <script type="text/javascript">     

  7 $(document).ready(function() { 

  8     //1、淡入显示效果

  9     $("img").lazyload({ 

 10         effect: "fadeIn",

 11     }); 

 12     //2、图片没有看到之前先load 200像素

 13     $("img").lazyload({

 14         threshold : 200

 15     });

 16     //3、通过设置占位符图片和自定事件来触发加载图片事件

 17     $("img").lazyload({

 18        placeholder: "img/grey.gif",      event: "click" 

 19     }); 

 20     //3、通过设置占位符图片和自定事件来触发加载图片事件

 21     $("img").lazyload({

 22        placeholder: "img/grey.gif",      event: "click"  

 23     }); 

 24     //4、页面加载完成后再加载. 页面加载完成 5 秒后, 指定区域内的图片会自动进行加载

 25     $(function() {

 26         $("img:below-the-fold").lazyload({                                    

 27            placeholder: "img/grey.gif",

 28            event: "sporty"

 29         });  

 30     });  

 31     $(window).bind("load", function() {

 32         var timeout = setTimeout(function() {

 33         $("img").trigger("sporty") }, 5000);  

 34     });

 35     //5、某个容器内实现图片加载

 36     $("img.lazy").lazyload({         

 37         container: $("#container")

 38     });

 39 });//以上列出了5种常用方法,根据自己的需求选择

 40  </script>

 41 ***/

 42 (function($, window) {

 43     var $window = $(window);

 44  

 45     $.fn.lazyload = function(options) {

 46         var elements = this;

 47         var $container;

 48         var settings = {

 49             threshold       : 0,

 50             failure_limit   : 0,

 51             event           : "scroll",

 52             effect          : "show",

 53             container       : window,

 54             data_attribute  : "original",

 55             skip_invisible  : true,

 56             appear          : null,

 57             load            : null

 58         };

 59  

 60         function update() {

 61             var counter = 0;

 62        

 63             elements.each(function() {

 64                 var $this = $(this);

 65                 if (settings.skip_invisible && !$this.is(":visible")) {

 66                     return;

 67                 }

 68                 if ($.abovethetop(this, settings) ||

 69                     $.leftofbegin(this, settings)) {

 70                 } else if (!$.belowthefold(this, settings) &&

 71                     !$.rightoffold(this, settings)) {

 72                         $this.trigger("appear");

 73                 } else {

 74                     if (++counter > settings.failure_limit) {

 75                         return false;

 76                     }

 77                 }

 78             });

 79  

 80         }

 81  

 82         if(options) {

 83             if (undefined !== options.failurelimit) {

 84                 options.failure_limit = options.failurelimit; 

 85                 delete options.failurelimit;

 86             }

 87             if (undefined !== options.effectspeed) {

 88                 options.effect_speed = options.effectspeed; 

 89                 delete options.effectspeed;

 90             }

 91  

 92             $.extend(settings, options);

 93         }

 94  

 95         $container = (settings.container === undefined ||settings.container === window) ? $window : $(settings.container);

 96  

 97          if (0 === settings.event.indexOf("scroll")) {

 98              $container.bind(settings.event, function(event) {

 99                 return update();

100             });

101         }

102  

103         this.each(function() {

104             var self = this;

105             var $self = $(self);

106  

107             self.loaded = false;

108  

109             $self.one("appear", function() {

110                 if (!this.loaded) {

111                     if (settings.appear) {

112                         var elements_left = elements.length;

113                         settings.appear.call(self, elements_left, settings);

114                     }

115                     $("<img />").bind("load", function() {

116                         $self.hide().attr("src", $self.data(settings.data_attribute))[settings.effect](settings.effect_speed);

117                         self.loaded = true;

118                         var temp = $.grep(elements, function(element) {

119                             return !element.loaded;

120                         });

121                         elements = $(temp);

122 

123                         if (settings.load) {

124                             var elements_left = elements.length;

125                             settings.load.call(self, elements_left, settings);

126                         }

127                     })

128                     .attr("src", $self.data(settings.data_attribute));

129                 }

130             });

131  

132             if (0 !== settings.event.indexOf("scroll")) {

133                 $self.bind(settings.event, function(event) {

134                     if (!self.loaded) {

135                         $self.trigger("appear");

136                     }

137                 });

138             }

139         });

140  

141         $window.bind("resize", function(event) {

142             update();

143         });

144  

145         update();

146          

147         return this;

148     };

149  

150     $.belowthefold = function(element, settings) {

151         var fold;

152          

153         if (settings.container === undefined || settings.container === window) {

154             fold = $window.height() + $window.scrollTop();

155         } else {

156             fold = $(settings.container).offset().top + $(settings.container).height();

157         }

158  

159         return fold <= $(element).offset().top - settings.threshold;

160     };

161      

162     $.rightoffold = function(element, settings) {

163         var fold;

164  

165         if (settings.container === undefined || settings.container === window) {

166             fold = $window.width() + $window.scrollLeft();

167         } else {

168             fold = $(settings.container).offset().left + $(settings.container).width();

169         }

170  

171         return fold <= $(element).offset().left - settings.threshold;

172     };

173          

174     $.abovethetop = function(element, settings) {

175         var fold;

176          

177         if (settings.container === undefined || settings.container === window) {

178             fold = $window.scrollTop();

179         } else {

180             fold = $(settings.container).offset().top;

181         }

182  

183         return fold >= $(element).offset().top + settings.threshold  + $(element).height();

184     };

185      

186     $.leftofbegin = function(element, settings) {

187         var fold;

188          

189         if (settings.container === undefined || settings.container === window) {

190             fold = $window.scrollLeft();

191         } else {

192             fold = $(settings.container).offset().left;

193         }

194  

195         return fold >= $(element).offset().left + settings.threshold + $(element).width();

196     };

197  

198     $.inviewport = function(element, settings) {

199         return !$.rightofscreen(element, settings) && !$.leftofscreen(element, settings) && 

200         !$.belowthefold(element, settings) && !$.abovethetop(element, settings);

201     };

202  

203     $.extend($.expr[':'], {

204         "below-the-fold" : function(a) { return $.belowthefold(a, {threshold : 0}); },

205         "above-the-top"  : function(a) { return !$.belowthefold(a, {threshold : 0}); },

206         "right-of-screen": function(a) { return $.rightoffold(a, {threshold : 0}); },

207         "left-of-screen" : function(a) { return !$.rightoffold(a, {threshold : 0}); },

208         "in-viewport"    : function(a) { return !$.inviewport(a, {threshold : 0}); },

209         "above-the-fold" : function(a) { return !$.belowthefold(a, {threshold : 0}); },

210         "right-of-fold"  : function(a) { return $.rightoffold(a, {threshold : 0}); },

211         "left-of-fold"   : function(a) { return !$.rightoffold(a, {threshold : 0}); }

212     });

213  

214 })(jQuery, window);

怎样使用?

Lazy Load 依赖于 jQuery. 请将下列代码加入页面 head 区域:

<script src="jquery.js" type="text/javascript"></script>

<script src="jquery.lazyload.js" type="text/javascript"></script>

你必须修改 HTML 代码. 在 src 属性中设置展位符图片, demo 页面使用 1x1 像素灰色 GIF 图片. 并且需要将真实图片的 URL 设置到 data-original 属性. 这里可以定义特定的 class 以获得需要延迟加载的图片对象. 通过这种方法你可以简单地控制插件绑定.

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

处理图片的代码如下.

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

这将使所有 class  lazy 的图片将被延迟加载. 可以参考基本选项 demo

设置敏感度

几乎所有浏览器的 JavaScript 都是激活的. 然而可能你仍希望能在不支持 JavaScript 的客户端展示真实图片. 当浏览器不支持 JavaScript 时优雅降级, 你可以将真实的图片片段在写 <noscript> 标签内.

<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();

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

设置敏感度

默认情况下图片会出现在屏幕时加载. 如果你想提前加载图片, 可以设置 threshold 选项, 设置 threshold 为 200 令图片在距离屏幕 200 像素时提前加载.

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

占位图片

你还可以设定一个占位图片并定义事件来触发加载动作. 这时需要为占位图片设定一个 URL 地址. 透明, 灰色和白色的 1x1 象素的图片已经包含在插件里面.

事件触发加载

事件可以是任何 jQuery 时间, 如: click  mouseover. 你还可以使用自定义的事件, 如: sporty  foobar. 默认情况下处于等待状态, 直到用户滚动到窗口上图片所在位置. 在灰色占位图片被点击之前阻止加载图片, 你可以这样做:

$("img").lazyload({

	placeholder : "img/grey.gif",

	event : "click"

});

使用特效

当图片完全加载的时候, 插件默认地使用 show() 方法来将图显示出来. 其实你可以使用任何你想用的特效来处理. 下面的代码使用FadeIn 效果. 这是效果演示页面.

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

    effect : "fadeIn"

});

图片在容器里面

你可以将插件用在可滚动容器的图片上, 例如带滚动条的 DIV 元素. 你要做的只是将容器定义为 jQuery 对象并作为参数传到初始化方法里面. 这是水平滚动演示页面垂直滚动的演示页面.

#container {

    height: 600px;

    overflow: scroll;

}
$("img.lazy").lazyload({         

     container: $("#container")

});

当图片不顺序排列

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

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

    failure_limit : 10

});

 failurelimit 设为 10 令插件找到 10 个不在可见区域的图片是才停止搜索. 如果你有一个猥琐的布局, 请把这个参数设高一点.

延迟加载图片

Lazy Load 插件的一个不完整的功能, 但是这也能用来实现图片的延迟加载. 下面的代码实现了页面加载完成后再加载. 页面加载完成 5 秒后, 指定区域内的图片会自动进行加载. 这是延迟加载演示页面.

$(function() {          

    $("img:below-the-fold").lazyload({

        event : "sporty"

    });

});

$(window).bind("load", function() { 

    var timeout = setTimeout(function() {$("img.lazy").trigger("sporty")}, 5000);

});

加载隐藏的图片

可能在你的页面上埋藏可很多隐藏的图片. 比如插件用在对列表的筛选, 你可以不断地修改列表中各条目的显示状态. 为了提升性能, Lazy Load 默认忽略了隐藏图片. 如果你想要加载隐藏图片, 请将 skip_invisible 设为 false

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

    skip_invisible : false

});

你可能感兴趣的:(jquery)