04-DOM操作练习：Tab栏切换（通过className设置样式）

京东网页上，可以看到下面这种tab栏的切换：

04-DOM操作练习：Tab栏切换（通过className设置样式） - 图1

我们把模型抽象出来，实现一下。

举例引入：鼠标悬停时，current元素的背景变色

本段我们先举一个例子，因为这里用到了排他思想（先干掉 all，然后保留我一个）。对于理解tab切换，很有帮助。

完整的代码实现：

  1. <!DOCTYPE html>
  2. <html>
  3. <head lang="en">
  4.     <meta charset="UTF-8">
  5.     <title></title>
  6.     <style>
  7.         button {
  8.             margin: 10px;
  9.             width: 100px;
  10.             height: 40px;
  11.             cursor: pointer;
  12.         }
  13.         .current {
  14.             background-color: red;
  15.         }
  16.     </style>
  17. </head>
  18. <body>
  19. <button>按钮1</button>
  20. <button>按钮2</button>
  21. <button>按钮3</button>
  22. <button>按钮4</button>
  23. <button>按钮5</button>
  25. <script>
  26.     //需求：鼠标放到哪个button上，改button变成黄色背景（添加类）
  29.     var btnArr = document.getElementsByTagName("button");
  30.     //绑定事件
  31.     for(var i=0;i<btnArr.length;i++){   //要为每一个按钮绑定事件，所以用到了for循环
  32.         btnArr[i].onmouseover = function () {
  33.             //【重要】排他思想：先把所有按钮的className设置为空，然后把我（this）这个按钮的className设置为current
  34.             //排他思想和for循环连用
  35.             for(var j=0;j<btnArr.length;j++){
  36.                 btnArr[j].className = "";
  37.             }
  38.             this.className = "current";  //【重要】核心代码
  39.         }
  40.     }
  42.     //鼠标离开current时，还原背景色
  43.     for(var i=0;i<btnArr.length;i++){   //要为每一个按钮绑定事件，所以用到了for循环
  44.         btnArr[i].onmouseout = function () { //鼠标离开任何一个按钮时，就把按钮的背景色还原
  45.             this.className = "";
  46.         }
  47.     }
  49. </script>
  51. </body>
  52. </html>

代码解释：

鼠标悬停时，current栏变色，这里用到了排他思想：先把所有按钮的className设置为空，然后把我(this)这个按钮的className设置为current，就可以达到变色的效果。核心代码是：

  1.             //排他思想：先把所有按钮的className设置为空，然后把我（this）这个按钮的className设置为current
  2.             //排他思想和for循环连用
  3.             for(var j=0;j<btnArr.length;j++){
  4.                 btnArr[j].className = "";
  5.             }
  6.             this.className = "current";

实现的效果如下：

04-DOM操作练习：Tab栏切换（通过className设置样式） - 图2

tab切换：初步的代码

代码如下：

  1. <!DOCTYPE html>
  2. <html>
  3. <head lang="en">
  4.     <meta charset="UTF-8">
  5.     <title></title>
  6.     <style>
  7.         * {
  8.             padding: 0;
  9.             margin: 0;
  10.         }
  11.         .box {
  12.             width: 500px;
  13.             height: 200px;
  14.             border: 1px solid #ccc;
  15.             margin: 50px auto;
  16.             overflow: hidden;
  17.         }
  18.         ul {
  19.             width: 600px;
  20.             height: 40px;
  21.             margin-left: -1px;
  22.             list-style: none;
  23.         }
  24.         li {
  25.             float: left;
  26.             width: 101px;
  27.             height: 40px;
  28.             text-align: center;
  29.             font: 600 18px/40px "simsun";
  30.             background-color: pink;
  31.             cursor: pointer;
  32.         }
  33.         span {
  34.             display: none;
  35.             width: 500px;
  36.             height: 160px;
  37.             background-color: yellow;
  38.             text-align: center;
  39.             font: 700 100px/160px "simsun";
  40.         }
  41.         .show {
  42.             display: block;
  43.         }
  44.         .current {
  45.             background-color: yellow;
  46.         }
  47.     </style>
  49.     <script>
  50.         window.onload = function () {
  51.             //需求：鼠标放到上面的li上，li本身变色(添加类)，对应的span也显示出来(添加类);
  52.             //思路：1.点亮上面的盒子。   2.利用索引值显示下面的盒子。
  54.             var liArr = document.getElementsByTagName("li");
  55.             var spanArr = document.getElementsByTagName("span");
  57.             for(var i=0;i<liArr.length;i++){
  58.                 //绑定索引值（新增一个自定义属性：index属性）
  59.                 liArr[i].index = i;
  60.                 liArr[i].onmouseover = function () {
  62.                     //1.点亮上面的盒子。   2.利用索引值显示下面的盒子。(排他思想)
  63.                     for(var j=0;j<liArr.length;j++){
  64.                         liArr[j].className = "";
  65.                         spanArr[j].className = "";
  66.                     }
  67.                     this.className = "current";
  68.                     spanArr[this.index].className = "show"; //【重要代码】
  69.                 }
  70.             }
  71.         }
  72.     </script>
  73. </head>
  74. <body>
  76. <div class="box">
  77.     <ul>
  78.         <li class="current">鞋子</li>
  79.         <li>袜子</li>
  80.         <li>帽子</li>
  81.         <li>裤子</li>
  82.         <li>裙子</li>
  83.     </ul>
  84.     <span class="show">鞋子</span>
  85.     <span>袜子</span>
  86.     <span>帽子</span>
  87.     <span>裤子</span>
  88.     <span>裙子</span>
  89. </div>
  91. </body>
  92. </html>

实现效果如下：

04-DOM操作练习：Tab栏切换（通过className设置样式） - 图3

上方代码的核心部分是：

  1.             for(var i=0;i<liArr.length;i++){
  2.                 //绑定索引值（新增一个自定义属性：index属性）
  3.                 liArr[i].index = i;
  4.                 liArr[i].onmouseover = function () {
  6.                     //1.点亮上面的盒子。   2.利用索引值显示下面的盒子。(排他思想)
  7.                     for(var j=0;j<liArr.length;j++){
  8.                         liArr[j].className = "";
  9.                         spanArr[j].className = "";
  10.                     }
  11.                     this.className = "current";
  12.                     spanArr[this.index].className = "show"; //【重要代码】
  13.                 }
  14.             }

这段代码中，我们是通过给 liArr[i]一个index属性：liArr[i].index = i，然后让下方的span对应的index也随之对应显示：spanArr[this.index].className = "show"。

这样做比较难理解，其实还有一种容易理解的方法是：给liArr[i]增加index属性时，通过attribute的方式，因为这种方式增加的属性是可以显示在标签上的。也就有了下面这样的代码：

  1.             for(var i=0;i<liArr.length;i++){
  2.                 //绑定索引值(自定义属性)，通过Attribute的方式【重要】
  3.                 liArr[i].setAttribute("index",i);
  4.                 liArr[i].onmouseover = function () {
  5.                     //3.书写事件驱动程序（排他思想）
  6.                     //1.点亮盒子。   2.利用索引值显示盒子。(排他思想)
  7.                     for(var j=0;j<liArr.length;j++){
  8.                         liArr[j].removeAttribute("class");
  9.                         spanArr[j].removeAttribute("class");
  10.                     }
  11.                     this.setAttribute("class","current");
  12.                     spanArr[this.getAttribute("index")].setAttribute("class","show");
  13.                 }
  14.             }

显示的效果是一样的，不同的地方在于，我们审查元素发现，li标签中确实新增了自定义的index属性：

04-DOM操作练习：Tab栏切换（通过className设置样式） - 图4

本段中，我们的目的已经达到了，不足的地方在于，本段中的代码是通过document获取的的标签，如果网页中有很多个这种tab选项卡，必然互相影响。

为了多个tab栏彼此独立，我们就需要通过封装函数的方式把他们抽取出来，于是就有了下面的改进版代码。

tab切换：改进版代码（函数封装）

方式一：给current标签设置index值【推荐的代码】

完整版代码实现：

  1. <!DOCTYPE html>
  2. <html>
  3. <head lang="en">
  4.     <meta charset="UTF-8">
  5.     <title></title>
  6.     <style>
  7.         * {
  8.             padding: 0;
  9.             margin: 0;
  10.         }
  12.         .box {
  13.             width: 500px;
  14.             height: 200px;
  15.             border: 1px solid #ccc;
  16.             margin: 50px auto;
  17.             overflow: hidden;
  18.         }
  20.         ul {
  21.             width: 600px;
  22.             height: 40px;
  23.             margin-left: -1px;
  24.             list-style: none;
  25.         }
  27.         li {
  28.             float: left;
  29.             width: 101px;
  30.             height: 40px;
  31.             text-align: center;
  32.             font: 600 18px/40px "simsun";
  33.             background-color: pink;
  34.             cursor: pointer;
  35.         }
  37.         span {
  38.             display: none;
  39.             width: 500px;
  40.             height: 160px;
  41.             background-color: yellow;
  42.             text-align: center;
  43.             font: 700 100px/160px "simsun";
  44.         }
  46.         .show {
  47.             display: block;
  48.         }
  50.         .current {
  51.             background-color: yellow;
  52.         }
  53.     </style>
  55.     <script>
  56.         window.onload = function () {
  57.             //需求：鼠标放到上面的li上，li本身变色(添加类)，下方对应的span也显示出来(添加类);
  58.             //思路：1.点亮上面的盒子。   2.利用索引值显示下面的对应的盒子。
  60.             //1、获取所有的box
  61.             var boxArr = document.getElementsByClassName("box");
  63.             //让每一个box都调用函数
  64.             for (var i = 0; i < boxArr.length; i++) {
  65.                 fn(boxArr[i]);
  66.             }
  68.             function fn(element) {
  69.                 var liArr = element.getElementsByTagName("li");   //注意，是element获取事件源，不是document获取事件源
  70.                 var spanArr = element.getElementsByTagName("span");
  71.                 //2.绑定事件（循环绑定）
  72.                 for (var i = 0; i < liArr.length; i++) {
  73.                     //绑定索引值（新增一个自定义属性：index属性）
  74.                     liArr[i].index = i;
  75.                     liArr[i].onmouseover = function () {
  76.                         //3.书写事件驱动程序（排他思想）
  77.                         //1.点亮上面的盒子。   2.利用索引值显示下面的盒子。(排他思想)
  78.                         for (var j = 0; j < liArr.length; j++) {
  79.                             liArr[j].className = "";
  80.                             spanArr[j].className = "";
  81.                         }
  82.                         this.className = "current";
  83.                         spanArr[this.index].className = "show"; //【重要】核心代码
  84.                     }
  85.                 }
  86.             }
  87.         }
  88.     </script>
  89. </head>
  90. <body>
  92. <div class="box">
  93.     <ul>
  94.         <li class="current">鞋子</li>
  95.         <li>袜子</li>
  96.         <li>帽子</li>
  97.         <li>裤子</li>
  98.         <li>裙子</li>
  99.     </ul>
  100.     <span class="show">鞋子</span>
  101.     <span>袜子</span>
  102.     <span>帽子</span>
  103.     <span>裤子</span>
  104.     <span>裙子</span>
  105. </div>
  107. <div class="box">
  108.     <ul>
  109.         <li class="current">鞋子</li>
  110.         <li>袜子</li>
  111.         <li>帽子</li>
  112.         <li>裤子</li>
  113.         <li>裙子</li>
  114.     </ul>
  115.     <span class="show">鞋子</span>
  116.     <span>袜子</span>
  117.     <span>帽子</span>
  118.     <span>裤子</span>
  119.     <span>裙子</span>
  120. </div>
  122. <div class="box">
  123.     <ul>
  124.         <li class="current">鞋子</li>
  125.         <li>袜子</li>
  126.         <li>帽子</li>
  127.         <li>裤子</li>
  128.         <li>裙子</li>
  129.     </ul>
  130.     <span class="show">鞋子</span>
  131.     <span>袜子</span>
  132.     <span>帽子</span>
  133.     <span>裤子</span>
  134.     <span>裙子</span>
  135. </div>
  137. </body>
  138. </html>

注意，通过函数fn的封装之后，我们是通过参数element获取元素，而不再是document了。这样可以达到“抽象性”的作用，各个tab栏之间相互独立。

上方代码中，我们是通过给 liArr[i]一个index属性：liArr[i].index = i，然后让下方的span对应的index也随之对应显示：spanArr[this.index].className = "show"。

这样做比较难理解，根据上一段的规律，当然还有一种容易理解的方法是：给liArr[i]增加index属性时，通过attribute的方式，因为这种方式增加的属性是可以显示在标签上的。也就有了下面的方式二。

方式二：通过attribute设置index的值

基于上面方式一中的代码，我们修改一下js部分的代码，其他部分的代码保持不变。js部分的代码如下：

  1.     <script>
  2.         window.onload = function () {
  3.             //需求：鼠标放到上面的li上，li本身变色(添加类)，下方对应的span也显示出来(添加类);
  4.             //思路：1.点亮上面的盒子。   2.利用索引值显示下面的对应的盒子。
  6.             //1、获取所有的box
  7.             var boxArr = document.getElementsByClassName("box");
  9.             //让每一个box都调用函数
  10.             for (var i = 0; i < boxArr.length; i++) {
  11.                 fn(boxArr[i]);
  12.             }
  14.             function fn(element) {
  15.                 var liArr = element.getElementsByTagName("li");   //注意，是element获取事件源，不是document获取事件源
  16.                 var spanArr = element.getElementsByTagName("span");
  17.                 //2.绑定事件（循环绑定）
  18.                 for (var i = 0; i < liArr.length; i++) {
  19.                     //绑定索引值(自定义属性)
  20.                     liArr[i].setAttribute("index", i);
  21.                     liArr[i].onmouseover = function () {
  22.                         //3.书写事件驱动程序（排他思想）
  23.                         //1.点亮盒子。   2.利用索引值显示盒子。(排他思想)
  24.                         for (var j = 0; j < liArr.length; j++) {
  25.                             liArr[j].removeAttribute("class");    //注意，这里是class，不是className
  26.                             spanArr[j].removeAttribute("class");
  27.                         }
  28.                         this.setAttribute("class", "current");
  29.                         spanArr[this.getAttribute("index")].setAttribute("class", "show");
  30.                     }
  31.                 }
  32.             }
  33.         }
  34.     </script>

不过，方式一的写法应该比方式二更常见。

总结：通过函数封装的形式，可以保证各个tab栏之间的切换互不打扰。最终实现效果如下：

04-DOM操作练习：Tab栏切换（通过className设置样式） - 图5

我的公众号

想学习更多技能？不妨关注我的微信公众号：千古壹号（id：qianguyihao）。

扫一扫，你将发现另一个全新的世界，而这将是一场美丽的意外：

04-DOM操作练习：Tab栏切换（通过className设置样式） - 图6