devbox
繁依Fanyi0
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

原生js实现轮播图的两种方法_轮播图js

作者：繁依Fanyi0 | 2024-03-20 00:34:33

赞

踩

轮播图js

一.原生js实现幻灯片效果（直接跳转法）

1.分析需求：

幻灯片的效果就是在一个可视区域里面，若干个图片进行交替出现，像在下面的图中，可视区域中的图是轮流出现的。

 

那么如何来实现这个效果呢，我百度了一下大部分都是什么调节left的大小，我没看懂，于是自己来动手来思考怎么做。

首先，刚开始的时候，这个区域就只放一张图，等到需要切换的时候就把这个img的src属性修改为需要展示图片所在的位置。

 

那么如何来实现这个功能呢？

首先来定义一个全局数组用来存放所有的图片的位置，还有一个全局变量num用来记载这次应该轮到第几个图片位置出现在该区域

  1. var num = 0;
  2.  
  3. var arrUrl = ["img/1.jpg","img/2.jpg","img/3.jpg","img/4.jpg","img/5.jpg"];

接下来写切换函数，切换函数的主要功能就是将img的src属性改到当前需要的位置。

  1. function changeImg(){
  2.  
  3.     img.src = arrUrl[num];//修改图片的src位置
  4.  
  5.     //如果图片下方有需要显示的圆点就在这里修改，或者其他对应的信息也在这里修改
  6.  
  7.     for(var i = 0;i<arrUrl.length;i++){
  8.  
  9.         li[i].className = "";
  10.  
  11.         }
  12.  
  13.     li[num] = "active";
  14.  
  15.  
  16.  
  17. }
  18.

接下来分析需要切换的事件

首先是轮播切换，就是一个定时器，定时的调用这个切换函数，并且这里需要注意num的值，因为num切换到最后一张，下一张就应该是第一张。

接下来是点击左右切换按钮，左切换按钮要留意切换到第一张的时候，需要将下一张定义为最后一张，右切换按钮需要留意最后一张，下一张是第一张。

最后是小圆点点击跳转到对应的图片。

 

  • 按照上面的思路，首先来写轮播切换，轮播切换无非就是一个定时器，定时的切换这个图片，所以我们来写一个定时切换的函数

定义一个全局变量定时器（当需要停止定时切换的时候就清除，需要继续的时候就继续调用）

  1. var timer = null;//定义一个空对象来存放定时器
  2.  
  3. function autoPlay(){
  4.  
  5.     timer = setInterval(function(){
  6.  
  7.         num++;//切换下一张的num
  8.  
  9.         num %=arrUrl.length;//这里是关键，循环播放图片的关键
  10.  
  11.         },2000);//定时器
  12.  
  13. }
  14.

这里就是定时器的方法实现了，是不是很简单。

只要在全局函数中调用就可以了

 

setTimeout(autoPlay,1000);//延时播放，这样就不用一刷新页面立马切换图片。

 

  • 接下来就是左右切换图片的实现了。左边切换的时候num--，但是要注意num=0的时候，下一场num=arr.Url.length，右切换则相反。

  1. left.onclik = function(){
  2.  
  3.     num--;
  4.  
  5.     if(num == -1){
  6.  
  7.         num = arrUrl.length-1;
  8.  
  9.     }
  10.  
  11.     changeImg();//调用切换函数
  12.  
  13. }
  14.  
  15.  
  16.  
  17. right.onclik = function(){
  18.  
  19.     num++;
  20.  
  21.     if(num == arrUrl.length){
  22.  
  23.         num =0;
  24.  
  25.     }
  26.  
  27.     changeImg();//调用切换函数
  28.  
  29. }

 

 

  • 当图片下面的小圆点点击跳到对应的图片。这里需要为每个原点的index属性添加一个值，就是它对应的i的值，这样每次点击小圆点，直接将img.src = arrUrl[this.index]就可以了。

  1. for(i = 0;i<arrUrl.length;i++){
  2.  
  3.     li[i].index = i;
  4.  
  5.         li[i].onclick = function(){
  6.  
  7.           num = this.index;
  8.  
  9.             changeImg();
  10.  
  11.         }
  12.  
  13. }
  14.

 

到了这里，基本都完成了，再添加一个鼠标移入清除定时器，鼠标移出继续调用就可以了

  1. content.onmouseover = function(){
  2.  
  3.         clearInterval(timer);
  4.  
  5.     }
  6.  
  7. contentonmouseout= aotoPlay;

下面是全部的代码

  1. <!DOCTYPE html>
  2.  
  3. <html lang="en">
  4.  
  5. <head>
  6.  
  7.     <meta charset="UTF-8">
  8.  
  9.     <title>原生js实现幻灯片</title>
  10.  
  11. </head>
  12.  
  13. <style>
  14.  
  15.     .container{
  16.  
  17.         width: 100%;
  18.  
  19.         height: 500px;
  20.  
  21.         position: relative;
  22.  
  23.     }
  24.  
  25.     .content{
  26.  
  27.         width: 900px;
  28.  
  29.         height: 450px;
  30.  
  31.         position: relative;
  32.  
  33.         overflow: hidden;
  34.  
  35.         border: 1px solid seagreen;
  36.  
  37.         margin: 0 auto;
  38.  
  39.     }
  40.  
  41.     .slider-img{
  42.  
  43.         width: 900px;
  44.  
  45.         height: 450px;
  46.  
  47.         margin: 10px auto;
  48.  
  49.     }
  50.  
  51.     .slider-img img{
  52.  
  53.         vertical-align: top;
  54.  
  55.         width: 800px;
  56.  
  57.         height: 400px;
  58.  
  59.         margin: 10px 50px;
  60.  
  61.         display: block;
  62.  
  63.     }
  64.  
  65.     .left{
  66.  
  67.         margin-top: -300px;
  68.  
  69.         margin-left: 50px;
  70.  
  71.         width: 100px;
  72.  
  73.         height: 100px;
  74.  
  75.  
  76.  
  77.     }
  78.  
  79.     .left img,.right img{
  80.  
  81.         width: 100px;
  82.  
  83.         height: 100px;
  84.  
  85.     }
  86.  
  87.     .right{
  88.  
  89.         margin-top: -100px;
  90.  
  91.         margin-right: 50px;
  92.  
  93.         float: right;
  94.  
  95.         width: 100px;
  96.  
  97.         height: 100px;
  98.  
  99.     }
  100.  
  101.  
  102.  
  103.     .dot{
  104.  
  105.         position: relative;
  106.  
  107.         top: 23%;
  108.  
  109.         left: 43%;
  110.  
  111.         width: 50%;
  112.  
  113.     }
  114.  
  115.     .dotul{
  116.  
  117.         width: 450px;
  118.  
  119.  
  120.  
  121.     }
  122.  
  123.     .dotul li{
  124.  
  125.         width: 20px;
  126.  
  127.         height: 20px;
  128.  
  129.         background-color: seagreen;
  130.  
  131.         list-style: none;
  132.  
  133.         float: left;
  134.  
  135.         border-radius: 20px;
  136.  
  137.         margin-left: 15px;
  138.  
  139.         z-index: 999;
  140.  
  141.         cursor: pointer;
  142.  
  143.     }
  144.  
  145.     .active{
  146.  
  147.         background-color: orangered !important;
  148.  
  149.     }
  150.  
  151.  
  152.  
  153. </style>
  154.  
  155. <body>
  156.  
  157.     <div class="container" id="contaner">
  158.  
  159.         <div class="content" id="content">
  160.  
  161.             <div class="slider-img" id="slider" >
  162.  
  163.                 <a href="javascript:;">
  164.  
  165.                     <img src="../img/1.jpg" alt="1.jpg" id="img">
  166.  
  167.                 </a>
  168.  
  169.             </div>
  170.  
  171.         </div>
  172.  
  173.         <div class="btn">
  174.  
  175.             <div class="left" id="left">
  176.  
  177.                 <a href=" ###"><img src="../img/left.png"></a>
  178.  
  179.             </div>
  180.  
  181.             <div class="right" id="right">
  182.  
  183.                 <a href=" ###"><img src="../img/right.png"></a>
  184.  
  185.             </div>
  186.  
  187.         </div>
  188.  
  189.         <div class="dot">
  190.  
  191.             <ul id="ul" class="dotul">
  192.  
  193.                 <li class="active"></li>
  194.  
  195.                 <li></li>
  196.  
  197.                 <li></li>
  198.  
  199.                 <li></li>
  200.  
  201.                 <li></li>
  202.  
  203.             </ul>
  204.  
  205.         </div>
  206.  
  207.  
  208.  
  209.     </div>
  210.  
  211. <script>
  212.  
  213.     //首先要获取元素
  214.  
  215.     var container = document.getElementById("container");
  216.  
  217.     var content = document.getElementById("content");
  218.  
  219.     var slider = document.getElementById("slider");
  220.  
  221.     var img = document.getElementById("img");
  222.  
  223.     var ul = document.getElementById("ul");
  224.  
  225.     var li = document.getElementsByTagName("li");
  226.  
  227.     var left = document.getElementById("left");
  228.  
  229.     var right = document.getElementById("right");
  230.  
  231.     var num = 0;
  232.  
  233.     var timer = null;
  234.  
  235.  
  236.  
  237.  
  238.  
  239.     //图片位置
  240.  
  241.     var arrUrl = ["../img/1.jpg","../img/2.jpg","../img/3.jpg","../img/4.jpg","../img/5.jpg"];
  242.  
  243.     left.onclick = function (ev) {
  244.  
  245.         num--;
  246.  
  247.         if (num == -1){
  248.  
  249.             num = arrUrl.length-1;//如果到了第一张，返回最后一张
  250.  
  251.         }
  252.  
  253.         changeImg();
  254.  
  255.     };
  256.  
  257.     right.onclick = function (ev) {
  258.  
  259.         num++;
  260.  
  261.         if (num == arrUrl.length){
  262.  
  263.             num = 0;//如果是最后一张，则返回第一张
  264.  
  265.         }
  266.  
  267.         changeImg();
  268.  
  269.     };
  270.  
  271.     //点击小圆点跳转到对应的图片
  272.  
  273.     for (var i=0;i<arrUrl.length;i++){
  274.  
  275.            li[i].index = i;
  276.  
  277.            li[i].onclick = function (ev) {
  278.  
  279.                num = this.index;
  280.  
  281.                changeImg();
  282.  
  283.            }
  284.  
  285.     }
  286.  
  287.  
  288.  
  289.     setTimeout(autoPlay(),1000);//延迟1秒执行自动切换
  290.  
  291.  
  292.  
  293.     //鼠标移入清除定时器，鼠标移出恢复
  294.  
  295.     content.onmouseover = function (ev) {
  296.  
  297.         clearInterval(timer);
  298.  
  299.     };
  300.  
  301.     content.onmouseout = autoPlay;
  302.  
  303.  
  304.  
  305.     //图片切换函数
  306.  
  307.     function changeImg() {
  308.  
  309.         img.src = arrUrl[num];//改变图片src位置
  310.  
  311.         for (var i = 0;i< li.length;i++){//改变原点样式
  312.  
  313.             li[i].className = "";
  314.  
  315.         }
  316.  
  317.         li[num].className = "active";
  318.  
  319.     }
  320.  
  321.     //设置定时器
  322.  
  323.     function autoPlay() {
  324.  
  325.         timer = setInterval(function () {
  326.  
  327.             num++;
  328.  
  329.             num %= arrUrl.length;
  330.  
  331.             changeImg();
  332.  
  333.         },2000);
  334.  
  335.     }
  336.  
  337. </script>
  338.  
  339. </body>
  340.  
  341. </html>

 

 

 

 

二.原生js实现幻灯片效果（左右切换法）

因为第一种方法中，虽然可以实现了幻灯片，但是就是视觉效果不太好。因为突然的跳转，没有一个过渡的缓冲。所以我们再来做一个左右切换幻灯片的效果。

 

我们可以这样想，我们有一副很长的画，但是只有一个窗口，所以每次要看完这幅画都只能在这个窗口往左拉或者往右边拉这幅画，那么这样就实现了轮播的效果了。

 

那么怎么来实现呢？

首先我们要将容器都设上position（因为我们拉这幅画的时候，是通过容器的left来拉动的，而改变这个left使得其起效果，就必须设定position（不能设定为static））；

 

我们将最外层的容器设定为position:relative，因为这两层容器只是起到定位的效果，所以我们将其position设定为relative，让他们待在它们原本应该待的地方。

 

然后将放这幅画的容器（放置所有图片最内层的容器）position设定为absolute使其脱离文档流。为什么要这样做呢？

我的思考结果是：有两个原因：（1）因为必须设定Position，所以这里的取值就是relative,和absolute了，至于为什么，请参考笔记Position的研究.（2）选择absolute是因为它脱离了文档流，所以当一张图片需要切换到下一张图片的时候，原来图片的位置不会被占用，而是给了下一张图片的位置了。而子元素又继承了父元素的Position。所以当ul设定了position:absolute的时候，li的position也是absolute，这样就是切换元素的基础。

 

 

其他的样式就不详细说明了，只要保证设定了Position了就可以了。其他按照需要的样式设定就可以了

 

接下来，思考js部分需要怎么写。

首先在js中需要先设定ul的width是所有图片的width的总和。因为这样设定后，后面用js来改变left、width就会起作用。

 

当按下下一张的按钮的时候会发生什么呢？我们来思考一下。

既然按下下一张的时候需要切换到下一张图片，那么此时，我们就要往左边拉这幅长图，怎么拉？把left的值设定为负的一张图的宽度，例如一张图的宽度为500px，那么此时left就等于-500px，此处需要注意的是，这个符号一定要是字符串形式的！！！要用双引号括起来。

 

这个时候我们又会想到，如果这样一直拉，当拉到最后的时候，就是没有元素了吗？此时如果我们再拉，就没有任何元素了怎么办？

 

这是就想到了像数据结构中的循环链表一样了，我们拉这幅画，它是循环的，就是永远没有结尾的，就解决了这个问题。

 

那么怎么实现呢？

我们可以每次拉完这幅图画，就把刚刚拉的那个图画插到长图的最后，此时使用appengChild()函数实现，

（这个函数除了在原来的父元素上添加子元素之外还有一个功能就是，将原来的子元素删除，重新插入到父元素中。）

 

 

 

如果需要呈现慢慢拉到下一张的效果，就一点点的设置left的值，可以设置一个定时器，每次只拉一点点，直到拉完了这幅图，就清除这个定时器。

  1. next.onclick = function (ev) {
  2.  
  3.   liwidth = 0;
  4.  
  5.   nextTimer = setInterval(nextImg,animationSpeed);
  6.  
  7. };
  8.  
  9. function nextImg() {
  10.  
  11.     imgul.style.left = "-"+liwidth+"px";
  12.  
  13.     liwidth += minSpeed;
  14.  
  15.     if (liwidth >= imgli[0].offsetWidth){
  16.  
  17.         clearInterval(nextTimer);
  18.  
  19.         imgul.appendChild(imgli[0]);//先删除imgli[0],然后加到末尾来，这样实现了循环
  20.  
  21.         imgul.style.left = 0;
  22.  
  23.     }
  24.  
  25. }

 

这样，核心功能就完成了。

下面来想，如果是切换上一页的呢？

我们来想，如果按下切换上一页，会发生些什么？

就是left不断的减少，操作跟按右边的刚好相反，按下一张的时候是从0到-width，那么按上一页就是从-width到0。

按照这样的想法，写按上一页的逻辑

  1. prev.onclick = function (ev) {
  2.  
  3.     imgul.insertBefore(imgli[length-1],imgli[0]);//因为当前图片的位置一直都是imgli[0]，所以按照循环的思想，上一张就是imli[length-1]
  4.  
  5.     clearInterval(prevTimer);
  6.  
  7.     liwidth = imgli[0].offsetWidth;
  8.  
  9.     prevTimer = setInterval(prevImg,animationSpeed);
  10.  
  11. };
  12.  
  13. function prevImg() {
  14.  
  15.     imgul.style.left = "-"+liwidth+"px";
  16.  
  17.     liwidth -= minSpeed;
  18.  
  19.     if (liwidth <=-1){
  20.  
  21.         clearInterval(prevTimer);
  22.  
  23.         imgul.style.left = 0;
  24.  
  25.     }
  26.  
  27. }

 

写完切换的逻辑，接下来就写轮播的逻辑

轮播的逻辑就是一个定时器，定时的执行切换下一页的操作。

mainTimer = setInterval(next.onclick,5000);

 

那么到了这里，轮播图的基本逻辑基本上都实现了。

 

但是到了这里我发现了一个bug，就是定时器到了要触发切换的时候，如果我们点击下一页的话，此时会出现一点延迟，（不知道怎么表达，反正就是用户体验不好）。

 

我思考了一下，发现，这个问题的出现，就是当切换到一半的时候，点击了切换下一页，此时，定时器被清除，重新定义定时器。所以就会出现延迟的效果。

 

所以我们定义一个变量，用来记载是否在渲染，如果在渲染，就不再渲染，但是如果没有被渲染，就再一次渲染。

  1. next.onclick = function (ev) {
  2.  
  3. if (type){
  4.  
  5.      liwidth = 0;
  6.  
  7.      clearInterval(nextTimer);//先把上一次留下来的定时器清除（确保清除干净—）
  8.  
  9.      nextTimer = setInterval(nextImg,animationSpeed);
  10.  
  11.      type = false;
  12.  
  13. }
  14.  
  15. };
  16.  
  17. function nextImg() {
  18.  
  19.     imgul.style.left = "-"+liwidth+"px";
  20.  
  21.     liwidth += minSpeed;
  22.  
  23.     if (liwidth >= imgli[0].offsetWidth){
  24.  
  25.         clearInterval(nextTimer);
  26.  
  27.         imgul.appendChild(imgli[0]);//先删除imgli[0],然后加到末尾来，这样实现了循环
  28.  
  29.         imgul.style.left = 0;
  30.  
  31.         type = true;
  32.  
  33.     }
  34.  
  35. }
  36.  
  37. prev.onclick = function (ev) {
  38.  
  39.     if (type){//如果可以渲染
  40.  
  41.         imgul.insertBefore(imgli[length-1],imgli[0]);//因为当前图片的位置一直都是imgli[0]，所以按照循环的思想，上一张就是imli[length-1]
  42.  
  43.         clearInterval(prevTimer);
  44.  
  45.         liwidth = imgli[0].offsetWidth;
  46.  
  47.         prevTimer = setInterval(prevImg,animationSpeed);
  48.  
  49.         type = false;//因为设置了定时器，定时器在渲染，所以这时不能被渲染
  50.  
  51.     }
  52.  
  53.     };
  54.  
  55.  
  56.  
  57. function prevImg() {
  58.  
  59.     imgul.style.left = "-"+liwidth+"px";
  60.  
  61.     liwidth -= minSpeed;
  62.  
  63.     if (liwidth <=-1){
  64.  
  65.         clearInterval(prevTimer);
  66.  
  67.         imgul.style.left = 0;
  68.  
  69.         type = true;//定时器已经完成渲染了，所以此时可以渲染
  70.  
  71.     }
  72.  
  73. }
  74.  
  75. mainTimer = setInterval(next.onclick,5000);

 

这里基本功能就真的完成啦，现在还差一个小圆点的效果。就是切换到哪一页的时候，哪一页对应的小圆点的背景颜色发生改变。还有当点击哪个小圆点的时候，切换到哪一个小圆点。

 

我们先来思考一下，怎么改变小圆点的背景颜色，因为当前图片的位置一直都是imgli[0]，所以我们每次把li[0]的背景颜色改变就好。

那么怎么执行呢？因为如果每次都直接改变dotli[0]的值，那么被改变颜色的一直都只是第一个小圆点。

 

所以我们为没给li加上一个index属性，图片的li和小圆点的li都要加上，这个index的值等于还没有进行切换时的初始值，所以虽然每次当前图片的值都是imgli[0]，但是它们对应的index的值是不一样的。所以我们通过这个值进行改变。

 

但是我们发现，如果直接设置的是index是当前，由于定时器完成渲染需要一定的时间，所以小圆点改变背景颜色的时间会有点突兀。所以我们在设置完定时器之后，就改变下一个li的值了，因为此时li仍然是当前值。

 

 

 

接下来来思考当点击小圆点的时候，如何跳转到对应的图片。

当我们点击一个小圆点的时候，先判断这个小圆点应该在当前照片的前面还是后面，如果是在当前图片的前面就往前翻，往前翻（就是从队尾到需要切换到的图片，不断的切换到第一位。）。如果是在当前图片的后面，就往后翻（从当前图片到需要切换到的图片之前的图片全部插到队伍的后面。）

 


 

  1. //为每个小圆点添加点击事件
  2.  
  3. dot.onclick = function(ev){
  4.  
  5.     var ev = ev || window.event;
  6.  
  7.     var target = ev.target || ev.srcElement;
  8.  
  9.     if(target.nodeName.toLowerCase() == "li"){
  10.  
  11.         if(type){
  12.  
  13.             showImg(target.index);
  14.  
  15.             changeColor(target);
  16.  
  17.             type = true;
  18.  
  19.         }
  20.  
  21.     }
  22.  
  23. };
  24.  
  25. //根据参数显示对应的图片。
  26.  
  27. function showImg(inde){
  28.  
  29.     var this_li = imgli[0].index;
  30.  
  31.  
  32.  
  33.     //把第一个元素放到最后面。
  34.  
  35.     if(inde>this_li){
  36.  
  37.         var x = inde-this_li;
  38.  
  39.         for(var y = 0;y<x;y++){
  40.  
  41.             imgul.appendChild(imgli[0]);
  42.  
  43.         }
  44.  
  45.     }
  46.  
  47.  
  48.  
  49.     //把最后一个元素放到第一的位置
  50.  
  51.     if(inde<this_li){
  52.  
  53.         var x_x = this_li-inde;
  54.  
  55.         for(var g = 0;g<x_x;g++){
  56.  
  57.             imgul.insertBefore(imgli[length-1],imgli[0]);
  58.  
  59.         }
  60.  
  61.     }
  62.  
  63. }
  64.

 

 

到这里所有的代码都写好了。

下面贴上所有的代码

 

  1. <!DOCTYPE html>
  2.  
  3. <html lang="en">
  4.  
  5. <head>
  6.  
  7. <meta charset="UTF-8">
  8.  
  9. <title>Title</title>
  10.  
  11. <style>
  12.  
  13. #banner{
  14.  
  15. width: 1000px;
  16.  
  17. height: 500px;
  18.  
  19. margin: 10px auto;
  20.  
  21. }
  22.  
  23. #content{
  24.  
  25. width: 1000px;
  26.  
  27. height: 500px;
  28.  
  29. overflow: hidden;
  30.  
  31. position: relative;
  32.  
  33. }
  34.  
  35. #ul{
  36.  
  37. height: 500px;
  38.  
  39. position: absolute;
  40.  
  41. left: 0;
  42.  
  43. }
  44.  
  45. #ul li{
  46.  
  47. list-style: none;
  48.  
  49. width: 1000px;
  50.  
  51. height: 500px;
  52.  
  53. float: left;
  54.  
  55. }
  56.  
  57. #ul img{
  58.  
  59. width: 1000px;
  60.  
  61. height: 500px;
  62.  
  63. }
  64.  
  65. .b{
  66.  
  67. width: 100px;
  68.  
  69. height: 100px;
  70.  
  71. position: absolute;
  72.  
  73. cursor: pointer;
  74.  
  75. }
  76.  
  77. .b img{
  78.  
  79. width: 100px;
  80.  
  81. height: 100px;
  82.  
  83. }
  84.  
  85. #left{
  86.  
  87. top: 200px;
  88.  
  89. left: 50px;
  90.  
  91. }
  92.  
  93. #right{
  94.  
  95. top: 200px;
  96.  
  97. right: 50px;
  98.  
  99. }
  100.  
  101. #dotul{
  102.  
  103. width: 500px;
  104.  
  105. position: relative;
  106.  
  107. left: 280px;
  108.  
  109. top: 450px;
  110.  
  111. }
  112.  
  113. #dotul li{
  114.  
  115. list-style: none;
  116.  
  117. float: left;
  118.  
  119. width: 20px;
  120.  
  121. height: 20px;
  122.  
  123. border-radius: 20px;
  124.  
  125. background-color: seagreen;
  126.  
  127. margin-left: 20px;
  128.  
  129. cursor: pointer;
  130.  
  131. }
  132.  
  133. .active{
  134.  
  135. background-color: orangered !important;
  136.  
  137. }
  138.  
  139. </style>
  140.  
  141. </head>
  142.  
  143. <body>
  144.  
  145. <div id="banner">
  146.  
  147. <div id="content">
  148.  
  149. <ul id="ul">
  150.  
  151. <li><a href="###"><img src="img/1.jpg" /></a> </li>
  152.  
  153. <li><a href="###"><img src="img/2.jpg" /></a> </li>
  154.  
  155. <li><a href="###"><img src="img/3.jpg" /></a> </li>
  156.  
  157. <li><a href="###"><img src="img/4.jpg" /></a> </li>
  158.  
  159. <li><a href="###"><img src="img/5.jpg" /></a> </li>
  160.  
  161. <li><a href="###"><img src="img/6.jpg" /></a> </li>
  162.  
  163. <li><a href="###"><img src="img/7.jpg" /></a> </li>
  164.  
  165. <li><a href="###"><img src="img/8.jpg" /></a> </li>
  166.  
  167. <li><a href="###"><img src="img/9.jpg" /></a> </li>
  168.  
  169. <li><a href="###"><img src="img/10.jpg" /></a> </li>
  170.  
  171. </ul>
  172.  
  173. <div class="dot" id="dot">
  174.  
  175. <ul id="dotul">
  176.  
  177. <li></li>
  178.  
  179. <li></li>
  180.  
  181. <li></li>
  182.  
  183. <li></li>
  184.  
  185. <li></li>
  186.  
  187. <li></li>
  188.  
  189. <li></li>
  190.  
  191. <li></li>
  192.  
  193. <li></li>
  194.  
  195. <li></li>
  196.  
  197. </ul>
  198.  
  199. </div>
  200.  
  201. </div>
  202.  
  203. <div id="btn">
  204.  
  205. <div id="left" class="b"><img src="img/prev.png"/></div>
  206.  
  207. <div id="right" class="b"><img src="img/next.png"/></div>
  208.  
  209. </div>
  210.  
  211. </div>
  212.  
  213. <script>
  214.  
  215. //定义所有需要用到的数据
  216.  
  217. var animationSpeed = 1;//一次切换的图片数（就是下一张图片的间隔）
  218.  
  219. var minSpeed = 5;//就是每次left增加或减少的数
  220.  
  221. var stopTime = 5000;//要隔多少秒开始切换下一张图片
  222.  
  223. //页面元素
  224.  
  225. var prev = document.getElementById("left");
  226.  
  227. var next = document.getElementById("right");
  228.  
  229. var banner = document.getElementById("banner");
  230.  
  231. var content = document.getElementById("content");
  232.  
  233. var imgul = document.getElementById("ul");
  234.  
  235. var imgli = document.getElementById("ul").getElementsByTagName("li");
  236.  
  237. var liwidth = document.getElementById("ul").getElementsByTagName("li")[0].offsetWidth;
  238.  
  239. var dot = document.getElementById("dot");
  240.  
  241. var dotul = document.getElementById("dotul");
  242.  
  243. var dotli = document.getElementById("dotul").getElementsByTagName('li');
  244.  
  245. var length = document.getElementById("dotul").getElementsByTagName('li').length;
  246.  
  247. var type = true;//是否可以渲染
  248.  
  249. var nextTimer = null;
  250.  
  251. var prevTimer = null;
  252.  
  253. var mainTimer = null;
  254.  
  255.  
  256.  
  257. imgul.style.width = liwidth*length+"px";//将ul的宽度设置为所有照片宽度的总和
  258.  
  259. //给每一个dotli添加一个index属性，方便改变小圆点的背景颜色
  260.  
  261. for (var i = 0;i<length;i++){
  262.  
  263. imgli[i].index = i;
  264.  
  265. dotli[i].index = i;
  266.  
  267. }
  268.  
  269. //给第一个小圆点加上背景
  270.  
  271. changeColor(imgli[0]);
  272.  
  273. next.onclick = function (ev) {
  274.  
  275. if (type){
  276.  
  277. liwidth = 0;
  278.  
  279. clearInterval(nextTimer);//先把上一次留下来的定时器清除（确保清除干净—）
  280.  
  281. nextTimer = setInterval(nextImg,animationSpeed);
  282.  
  283. type = false;
  284.  
  285. changeColor(imgli[1]);//改变原点颜色
  286.  
  287. }
  288.  
  289. };
  290.  
  291. function nextImg() {
  292.  
  293. imgul.style.left = "-"+liwidth+"px";
  294.  
  295. liwidth += minSpeed;
  296.  
  297. if (liwidth >= imgli[0].offsetWidth){
  298.  
  299. clearInterval(nextTimer);
  300.  
  301. imgul.appendChild(imgli[0]);//先删除imgli[0],然后加到末尾来，这样实现了循环
  302.  
  303. imgul.style.left = 0;
  304.  
  305. type = true;
  306.  
  307. }
  308.  
  309. }
  310.  
  311. prev.onclick = function (ev) {
  312.  
  313. if (type){//如果可以渲染
  314.  
  315. imgul.insertBefore(imgli[length-1],imgli[0]);//因为当前图片的位置一直都是imgli[0]，所以按照循环的思想，上一张就是imli[length-1]
  316.  
  317. clearInterval(prevTimer);
  318.  
  319. liwidth = imgli[0].offsetWidth;
  320.  
  321. prevTimer = setInterval(prevImg,animationSpeed);
  322.  
  323. type = false;//因为设置了定时器，定时器在渲染，所以这时不能被渲染
  324.  
  325. changeColor(imgli[1]);//改变原点颜色
  326.  
  327. }
  328.  
  329. };
  330.  
  331.  
  332.  
  333. function prevImg() {
  334.  
  335. imgul.style.left = "-"+liwidth+"px";
  336.  
  337. liwidth -= minSpeed;
  338.  
  339. if (liwidth <=-1){
  340.  
  341. clearInterval(prevTimer);
  342.  
  343. imgul.style.left = 0;
  344.  
  345. type = true;//定时器已经完成渲染了，所以此时可以渲染
  346.  
  347. }
  348.  
  349. }
  350.  
  351. mainTimer = setInterval(next.onclick,5000);
  352.  
  353.  
  354.  
  355. function changeColor(target) {
  356.  
  357. for (var j = 0;j<length;j++){
  358.  
  359. dotli[j].className = "";
  360.  
  361. }
  362.  
  363. dotli[target.index].className = "active";
  364.  
  365. }
  366.  
  367.  
  368.  
  369. //为每个小圆点添加点击事件
  370.  
  371. dot.onclick = function(ev){
  372.  
  373. var ev = ev || window.event;
  374.  
  375. var target = ev.target || ev.srcElement;
  376.  
  377. if(target.nodeName.toLowerCase() == "li"){
  378.  
  379. if(type){
  380.  
  381. showImg(target.index);
  382.  
  383. changeColor(target);
  384.  
  385. type = true;
  386.  
  387. }
  388.  
  389. }
  390.  
  391. };
  392.  
  393. //根据参数显示对应的图片。
  394.  
  395. function showImg(inde){
  396.  
  397. var this_li = imgli[0].index;
  398.  
  399.  
  400.  
  401. //把第一个元素放到最后面。
  402.  
  403. if(inde>this_li){
  404.  
  405. var x = inde-this_li;
  406.  
  407. for(var y = 0;y<x;y++){
  408.  
  409. imgul.appendChild(imgli[0]);
  410.  
  411. }
  412.  
  413. }
  414.  
  415.  
  416.  
  417. //把最后一个元素放到第一的位置
  418.  
  419. if(inde<this_li){
  420.  
  421. var x_x = this_li-inde;
  422.  
  423. for(var g = 0;g<x_x;g++){
  424.  
  425. imgul.insertBefore(imgli[length-1],imgli[0]);
  426.  
  427. }
  428.  
  429. }
  430.  
  431. }
  432.  
  433.  
  434.  
  435. //当鼠标移入图片区域时，清除定时器。鼠标移出时恢复定时器
  436.  
  437. content.onmouseover = function (ev) {
  438.  
  439.   clearInterval(mainTimer);
  440.  
  441. };
  442.  
  443. content.onmouseout = function (ev) {
  444.  
  445.   mainTimer = setInterval(next.onclick,stopTime);
  446.  
  447. };
  448.  
  449. </script>
  450.  
  451. </body>
  452.  
  453. </html>

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/繁依Fanyi0/article/detail/269373
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号