如何优雅简洁地实现时钟翻牌器(支持JS/Vue/React)

如何优雅简洁地实现时钟翻牌器(支持JS/Vue/React)_第1张图片

双十一剁手节过去了,大家应该在很多网页中看到了数字翻牌的效果吧,比如倒计时、数字增长等。相信很多人都已经自己独立实现过了,我也在网上看了一些demo,发现HTML结构大多比较复杂,用了4个并列的标签来放置前后两个“牌”。本文就来讲解下,如何进一步精简HTML,让结构简单,让JS方法封装得易使用。先来看看最终效果:

如何优雅简洁地实现时钟翻牌器(支持JS/Vue/React)_第2张图片

每个翻牌的HTML结构(精简至2个并列标签):


     
     
     
     
  1. class="flip down">

  2.      class="digital front number0">

     class="digital back number1">

  • 本次分享含有很多小技巧,灵活使用能够提升技术水平和工作效率,具体包括以下知识点:

    知识点1::before:after伪元素的使用

    知识点2:line-height: 0的妙用

    知识点3:transform-origin和perspective

    知识点4:backface-visibility

    知识点5:时间格式化函数的实现

    Let's do it!

    1 翻牌的构建

    1.1 基本结构

    首先解释下HTML的结构:

    
         
         
         
         
    1. class="flip down">

    2.     

           class="digital front number0">

        

         class="digital back number1">

  • 【说明】

    flip: 纸牌的外框

    down:表示向下翻牌动效,还有对于的up。后面章节会具体讲解。

    front: 表示位于前面的纸牌

    back: 表示位于后面的纸牌

    number*: 表示纸牌上的数字

    flip的CSS代码如下:

    
         
         
         
         
    1. .flip {

    2. display: inline-block;

    3. position: relative;

    4. width: 60px;

    5. height: 100px;

    6. line-height: 100px;

    7. border: solid 1px#000;

    8. border-radius: 10px;

    9. background: #fff;

    10. font-size: 66px;

    11. color: #fff;

    12. box-shadow: 006px rgba(0, 0, 0, .5);

    13. text-align: center;

    14. font-family: "Helvetica Neue"

    15. }

    这段代码很基础,就不再详细解释了。眼尖的同学可能发现了,为什么要设置background为#fff(白色)呢?最终效果明明是黑的。留个疑问,下一小节就会明白了。

    基本结构的效果是这样的:

    如何优雅简洁地实现时钟翻牌器(支持JS/Vue/React)_第3张图片

    1.2 构建纸牌并用伪元素拆分上下两部分

    由于每个纸牌是上下对折、翻转的,所以每个纸牌要拆分成上下两部分。可是HTML中每个纸牌只有一个标签,怎么拆分成两个呢?这里就用到了before和after伪元素。

    知识点1:伪元素的使用

    先看代码:

    
         
         
         
         
    1. .flip .digital:before,

    2. .flip .digital:after {

    3. content: "";

    4. position: absolute;

    5. left: 0;

    6. right: 0;

    7. background: #000;

    8. overflow: hidden;

    9. }

    10. .flip .digital:before {

    11. top: 0;

    12. bottom: 50%;

    13. border-radius: 10px10px00;

    14. }

    15. .flip .digital:after {

    16. top: 50%;

    17. bottom: 0;

    18. border-radius: 0010px10px;

    19. }

    :before和:after在digital内部生成了两个伪元素,其中,before用来生成纸牌的“上半张”,after用来生成纸牌的“下半张”。

    因此,before“上半张”为从“顶部( top:0)”到“距底一半( bottom:50%)”的部分,顶部两侧为圆角。

    同理,after“下半张”为“距顶一半( top:50%)”到“底部( bottom:0)”的部分,底部两侧为圆角。

    注意代码中的 content:""不能省略,否则伪元素是不显示的。

    效果如下:

    如何优雅简洁地实现时钟翻牌器(支持JS/Vue/React)_第4张图片

    回答上一章节的问题,为什么底层设置background为白色?

    答案很简单,元素内部的纸片边角和外层边角之间会有一点点的缝隙,这个缝隙会露出底部的白色,从视觉效果上看,更加具有立体感。

    然后,为上下部分中间添加一条水平折线。

    
         
         
         
         

        .flip .digital:before,

        .flip .digital:after {

    1. content: "";

    2. position: absolute;

    3. left: 0;

    4. right: 0;

    5. background: #000;

    6. overflow: hidden;

    7. + box-sizing: border-box;

    8.     }

        ...(略)

        .flip .digital:before {

    9. top: 0;

    10. bottom: 50%;

    11. border-radius: 10px10px00;

    12. + border-bottom: solid 1px#666;

    13.     }

    外层flip添加 box-sizing:border-box保证了下边框不会影响元素的原有高度。

    效果如下:

    如何优雅简洁地实现时钟翻牌器(支持JS/Vue/React)_第5张图片

    到这里,我们可以认为是4个小纸片,分别是:

    1. 前上:.digital.front:before

    2. 前下:.digital.front:after

    3. 后上:.digital.back:before

    4. 后下:.digital.back:after

    由于重叠在一起,只能看到一张纸牌。而看到的这个纸牌是后面(back)的纸牌,为什么呢?因为back的HTML写在了front的后面。不过没关系,后面我们会通过z-index来重新调整层叠顺序,先不着急。

    1.3 为纸牌添加文字

    还记的刚才的 content:""吗?纸牌的文字显示就用到了这个。

    先通过CSS定义好0~9的数字:

    
         
         
         
         
    1. .flip .number0:before,

    2. .flip .number0:after {

    3. content: "0";

    4. }

    5. .flip .number1:before,

    6. .flip .number1:after {

    7. content: "1";

    8. }

    9. .flip .number2:before,

    10. .flip .number2:after {

    11. content: "2";

    12. }

    13. ...(略)

    14. .flip .number9:before,

    15. .flip .number9:after {

    16. content: "9";

    17. }

    现在效果如下:

    如何优雅简洁地实现时钟翻牌器(支持JS/Vue/React)_第6张图片

    可以很明显的看到两个问题:

    1. 本应该在后面的back纸牌跑到了前面(z-index问题)

    2. 下半张纸牌的文字应该只显示下半部分。

    先来解决问题2,这里就涉及到了第二个知识点。

    知识点2:line-height: 0的妙用

    提到文字的显示,肯定会想到基线(baseline),可能你也曾经看过这个图:

    如何优雅简洁地实现时钟翻牌器(支持JS/Vue/React)_第7张图片

    关于基线(baseline)的计算,确实很麻烦,我也在这里绕了很久。其实理解line-height:0可以换个角度,会更容易理解,请看下图:

    如何优雅简洁地实现时钟翻牌器(支持JS/Vue/React)_第8张图片

    当line-height为200px,每行文字高度为200px,文字在200px高度的行间区域垂直居中;

    当line-height为100px,每行文字高度为100px,文字在100px高度的行间区域垂直居中;

    当line-height为0时,行间距为0,中线的位置也为0,所以文字只有下半部分留在容器内。

    利用line-height:0的特性,就可以很轻易实现“下半张”纸牌只显示文字的下半部分,并且与“上半张”纸牌很好的衔接在一起。

    在代码中设置line-height为0:

    
         
         
         
         

          .flip .digital:after {

    1. top: 50%;

    2. bottom: 0;

    3. border-radius: 0010px10px;

    4. + line-height: 0;

    5.     }

    效果如下:

    如何优雅简洁地实现时钟翻牌器(支持JS/Vue/React)_第9张图片

    1.4 设置纸牌的层叠关系

    首先,先看下“向下翻牌”的视频演示,直观感受下每个纸片的层级关系:

    按照实物图就可以确定每张纸片的z-index:

    如何优雅简洁地实现时钟翻牌器(支持JS/Vue/React)_第10张图片

    添加以下CSS代码:

    
         
         
         
         
    1. /*向下翻*/

    2. .flip.down .front:before {

    3. z-index: 3;

    4. }

    5. .flip.down .back:after {

    6. z-index: 2;

    7. }

    8. .flip.down .front:after,

    9. .flip.down .back:before {

    10. z-index: 1;

    11. }

    现在效果如下:

    如何优雅简洁地实现时钟翻牌器(支持JS/Vue/React)_第11张图片

    咦?怎么不对?别着急,这是因为我们只设置了层级,但是没有把后面纸牌的下半部翻转上去。

    添加翻转代码:

    
         
         
         
         

          .flip.down .back:after {

    1. z-index: 2;

    2. + transform-origin: 50% 0%;

    3. + transform: perspective(160px) rotateX(180deg);

    4.     }

    这里涉及到了知识点3。

    知识点3:transform-origin和perspective

    transform-origin是元素旋转的基本点。

    transform-origin: 50% 0%;表示将旋转基本点设置在横轴的中点,纵轴的顶点位置,如下图所示:

    如何优雅简洁地实现时钟翻牌器(支持JS/Vue/React)_第12张图片

    perspective(160px)可以理解为立体透视图的景深。在本次分享的效果中,我们的视角是正对牌面,并且纸牌位于视角中间。所以 transform-origin的第一个值(X轴位置)为50%。

    rotateX(180deg)表示以X轴进行翻转,对应这里就是上下翻转。这里已经通过transform-origin的第二个参数(Y轴位置:0%)将X轴放在了元素顶部。

    基于以上设置,已经可以正常显示了,如下图:

    如何优雅简洁地实现时钟翻牌器(支持JS/Vue/React)_第13张图片

    同理,“向上翻”也需要进行设置下。大家可以自己折两个纸片,参照上面的方法,应该很容易实现。这里不再重复讲解,直接放上代码,大家可以对比下哪里不同:

    
         
         
         
         
    1. /*向上翻*/

    2. .flip.up .front:after {

    3. z-index: 3;

    4. }

    5. .flip.up .back:before {

    6. z-index: 2;

    7. transform-origin: 50% 100%;

    8. transform: perspective(160px) rotateX(-180deg);

    9. }

    10. .flip.up .front:before,

    11. .flip.up .back:after {

    12. z-index: 1;

    13. }

    2 翻牌动画的实现

    现在纸片都已摆好了,剩下的就是实现CSS3动画,以及JS交互控制。

    2.1 CSS3翻牌动画

    我们还是以“向下翻”为例,再来看下之前的实物翻牌视频:

    可以看到,“向下翻”主要涉及两个元素的动画:

    1. 前面纸牌的上半部向下翻转180度。

    2. 后面纸牌的下半部(目前已翻转上去)向下翻转180度恢复原状态。

    直接上代码:

    
         
         
         
         
    1. .flip.down.go .front:before {

    2. transform-origin: 50% 100%;

    3. animation: frontFlipDown 0.6s ease-in-out both;

    4. box-shadow: 0-2px6px rgba(255, 255, 255, 0.3);

    5. }

    6. .flip.down.go .back:after {

    7. animation: backFlipDown 0.6s ease-in-out both;

    8. }

    9. @keyframes frontFlipDown {

    10.     0% {

    11. transform: perspective(160px) rotateX(0deg);

    12.     }

          100% {

    13. transform: perspective(160px) rotateX(-180deg);

    14.     }

    15. }

    16. @keyframes backFlipDown {

    17.     0% {

    18. transform: perspective(160px) rotateX(180deg);

    19.     }

          100% {

    20. transform: perspective(160px) rotateX(0deg);

    21.     }

    22. }

    以上代码涉及的知识点和原理没有新的东西,都已经讲解过了,就不详述了。box-shadow是为了给纸片的上边缘加一点白光,视觉效果更好一点。否则在翻转的时候,跟后面元素都是黑色,融在一起了。看看现在的效果:

    如何优雅简洁地实现时钟翻牌器(支持JS/Vue/React)_第14张图片

    显示不正常!为什么?因为前排上半部纸片的z-index最高,所以它在翻转到下半部的时候仍然遮挡住了其他纸片。怎么优雅的解决?超级简单,来看看第四个知识点:

    知识点4:backface-visibility

    backface-visibility表示元素的背面是否可见,默认为visible(可见)。

    这里的需求是,当前面上半部纸片翻转到一半的时候(90度)进入不可见状态。而纸牌翻转90度以后,正好是显露元素背面的开始,所以将backface-visibility设置为hidden即可完美解决!

    修改代码如下:

    
         
         
         
         

          .flip.down.go .front:before {

    1. transform-origin: 50% 100%;

    2. animation: frontFlipDown 0.6s ease-in-out both;

    3. box-shadow: 0-2px6px rgba(255, 255, 255, 0.3);

    4. + backface-visibility: hidden;

    5.     }

    现在效果很完美!

    如何优雅简洁地实现时钟翻牌器(支持JS/Vue/React)_第15张图片

    大家可以试着自己实现向上翻转效果,代码直接放出:

    
         
         
         
         
    1. .flip.up.go .front:after {

    2. transform-origin: 50% 0;

    3. animation: frontFlipUp 0.6s ease-in-out both;

    4. box-shadow: 02px6px rgba(255, 255, 255, 0.3);

    5. backface-visibility: hidden;

    6. }

    7. .flip.up.go .back:before {

    8. animation: backFlipUp 0.6s ease-in-out both;

    9. }

    10. @keyframes frontFlipUp {

    11.     0% {

            transform: perspective(160px) rotateX(0deg);

            }

      1. 100% {

    12.     transform: perspective(160px) rotateX(180deg);

    13.     }

    14. }

    15. @keyframes backFlipUp {

    16.     0% {

    17. transform: perspective(160px) rotateX(-180deg);

    18.     }

      1. 100% {

    19. transform: perspective(160px) rotateX(0deg);

    20.     }

    21. }

    2.2 JS实现翻牌交互

    现在我们来实现一个简单的交互。需求是:

    1. 点击“+”,向下翻牌,数字+1

    2. 点击“-”,向上翻牌,数字-1

    首先,修改下HTML:

    
         
         
         
         
    1. +    

      class="single-demo">

    2. M

      class="flip down" id="flip">

    3. class="digital front number0">

    4. class="digital back number1">

  • +

  • +

    class="btn-con">

  • +

  • +

  • +

  • 配套的CSS如下,仅为了demo好看,无实际作用:

    
         
         
         
         
    1. .single-demo {

    2. margin: 50pxauto;

    3. padding: 30px;

    4. width: 600px;

    5. text-align: center;

    6. border: solid 1px#999;

    7. }

    Javascript代码如下:

    
         
         
         
         
    1. var flip = document.getElementById('flip')

    2. var backNode = document.querySelector('.back')

    3. var frontNode = document.querySelector('.front')

    4. var btn = document.getElementById('btn')

    5. btn1.addEventListener('click', function() {

    6. flipDown();

    7. })

    8. btn2.addEventListener('click', function() {

    9. flipUp();

    10. })

    11. // 当前数字

    12. var count = 0

    13. // 是否正在翻转(防止翻转未结束就进行下一次翻转)

    14. var isFlipping = false

    15. // 向下翻转+1

    16. function flipDown() {

    17.     // 如果处于翻转中,则不执行

      1. if(isFlipping) {

      2.     return false

        }

        // 设置前牌的文字

    18. frontNode.setAttribute('class', 'digital front number'+ count)

    19.     // 计算后牌文字(越界判断)

          var nextCount = count >= 9? 0: (count + 1)

          // 设置后牌的文字

    20. backNode.setAttribute('class', 'digital back number'+ nextCount)

    21.     // 添加go,执行翻转动画

    22. flip.setAttribute('class', 'flip down go')

    23.     // 将翻转态设置为true

    24. isFlipping = true

    25.     // 翻转结束后,恢复状态

    26. setTimeout(function() {

      1.     // 去掉go

    27.     flip.setAttribute('class', 'flip down')

      1.     // 将翻转态设置为false

    28.     isFlipping = false

      1.     // 设置前牌文字为+1后的数字

    29.     frontNode.setAttribute('class', 'digital front number'+ nextCount)

      1.     // 更新当前文字

    30.     count = nextCount

    31.     }, 1000)

    32. }

    33. // 向上翻转-1(同理,注释略)

    34. function flipUp() {

      1. if(isFlipping) {

      2.     return false

        }

    35. frontNode.setAttribute('class', 'digital front number'+ count)

    36.     var nextCount = count <= 0? 9: (count - 1)

    37. backNode.setAttribute('class', 'digital back number'+ nextCount)

    38. flip.setAttribute('class', 'flip up go')

    39. isFlipping = true

    40. setTimeout(function() {

    41. flip.setAttribute('class', 'flip up')

    42. isFlipping = false

    43. frontNode.setAttribute('class', 'digital front number'+ nextCount)

    44. count = nextCount

    45.     }, 1000)

    46. }

    先看下交互效果:

    如何优雅简洁地实现时钟翻牌器(支持JS/Vue/React)_第16张图片

    这段Javascript代码很冗余,重复代码很多。在实际产品中,都是多个数字牌,这种方式显然无法应对。下一章节,我们来说下如何优雅的封装,以不变应万变。

    3 翻牌时钟的实现

    先看下最终效果:

    如何优雅简洁地实现时钟翻牌器(支持JS/Vue/React)_第17张图片

    3.1 HTML构建

    HTML代码如下:

    
         
         
         
         
    1. class="clock"id="clock">

    2.      class="flip down">

             class="digital front number0">

         class="digital back number1">

    class="flip down">

         class="digital front number0">

        

    class="digital back number1">

    :

    class="flip down">

         class="digital front number0">

         class="digital back number1">

    class="flip down">

         class="digital front number0">

         class="digital back number1">

    :

    class="flip down">

         class="digital front number0">

        

    class="digital back number1">

    class="flip down">

        

    class="digital front number0">

         class="digital back number1">

  • CSS代码如下(之前章节的CSS代码请保留):

    
         
         
         
         
    1. .clock {

    2. text-align: center;

    3. }

    4. .clock em {

    5. display: inline-block;

    6. line-height: 102px;

    7. font-size: 66px;

    8. font-style: normal;

    9. vertical-align: top;

    10. }

    效果如下,剩下的就是JS部分了。

    如何优雅简洁地实现时钟翻牌器(支持JS/Vue/React)_第18张图片

    3.2 构建Flipper类

    将每个翻牌封装成类,这样在应对多个翻牌的时候,可以方便的通过new Flipper()去独立控制每个翻牌对象。

    类的实现代码如下:

    
         
         
         
         
    1. functionFlipper(config) {

    2.     // 默认配置

      1. this.config = {

              // 时钟模块的节点

    3.     node: null,

    4.         // 初始前牌文字

    5.     frontText: 'number0',

    6.         // 初始后牌文字

    7.     backText: 'number1',

    8.         // 翻转动画时间(毫秒,与翻转动画CSS 设置的animation-duration时间要一致)

    9.     duration: 500

    10.     }

          // 节点的原本class,与html对应,方便后面添加/删除新的class

      1. this.nodeClass = {

    11. flip: 'flip',

    12. front: 'digital front',

    13. back: 'digital back'

    14.     }

          // 覆盖默认配置

          Object.assign(this.config, config)

          // 定位前后两个牌的DOM节点

          this.frontNode = this.config.node.querySelector('.front')

          this.backNode = this.config.node.querySelector('.back')

          // 是否处于翻牌动画过程中(防止动画未完成就进入下一次翻牌)

          this.isFlipping = false

          // 初始化

          this._init()

    15. }

    16. Flipper.prototype = {

    17. constructor: Flipper,

    18.     // 初始化

    19. _init: function() {

    20.         // 设置初始牌面字符

              this._setFront(this.config.frontText)

              this._setBack(this.config.backText)

          },

          // 设置前牌文字

    21. _setFront: function(className) {

      1.     this.frontNode.setAttribute('class', this.nodeClass.front + ' '+ className)

        },

        // 设置后牌文字

    22. _setBack: function(className) {

      1.     this.backNode.setAttribute('class', this.nodeClass.back + ' '+ className)

        },

    23. _flip: function(type, front, back) {

      1.     // 如果处于翻转中,则不执行

            if(this.isFlipping) {

              return false

          }

          // 设置翻转状态为true

              this.isFlipping = true

              // 设置前牌文字

              this._setFront(front)

              // 设置后牌文字

              this._setBack(back)

              // 根据传递过来的type设置翻转方向

              let flipClass = this.nodeClass.flip;

              if(type === 'down') {

    24. flipClass += ' down'

    25.         } else{

    26. flipClass += ' up'

      1.     }

            // 添加翻转方向和执行动画的class,执行翻转动画

            this.config.node.setAttribute('class', flipClass + ' go')

            // 根据设置的动画时间,在动画结束后,还原class并更新前牌文字

    27. setTimeout(() => {

      1.         // 还原class

                this.config.node.setAttribute('class', flipClass)

                // 设置翻转状态为false

                this.isFlipping = false

                // 将前牌文字设置为当前新的数字,后牌因为被前牌挡住了,就不用设置了。

                this._setFront(back)

            }, this.config.duration)

        },

        // 下翻牌

    28. flipDown: function(front, back) {

      1.     this._flip('down', front, back)

        },

        // 上翻牌

    29. flipUp: function(front, back) {

    30.         this._flip('up', front, back)

          }

    31. }

    可以注意到,Flipper的传参只接受一个对象形式的参数config,使用对象的方式向函数传参有很多优点:

    1. 参数语义化,方便理解

    2. 不用在意参数顺序

    3. 传参的增删和顺序调整不会影响业务代码的使用

    使用Object.assign方法,可将传递进来的config参数覆盖默认参数。传递的config中没有的属性,则使用默认配置。当然,这种方式只适用于浅拷贝。

    关于prototype,以及为什么要设置constructor,请阅读我的微信公众号(账号:卧梅又闻花)另一篇文章《一张刮刮卡竟包含这么多前端知识点》第4.1章节,已经讲解得很详细了。

    代码逻辑请阅读注释。

    3.3 实现时钟业务逻辑

    接下来的工作就是将js与dom进行绑定。

    请看代码:

    这段代码一定要放在Flipper类代码的下面,Flipper.prototype一定要在业务逻辑代码之前执行,否则会报错找不到Flipper内部方法。

    
         
         
         
         
    1. // 定位时钟模块

    2. let clock = document.getElementById('clock')

    3. // 定位6个翻板

    4. let flips = clock.querySelectorAll('.flip')

    5. // 获取当前时间

    6. let now = newDate()

    7. // 格式化当前时间,例如现在是20:30:10,则输出"203010"字符串

    8. let nowTimeStr = formatDate(now, 'hhiiss')

    9. // 格式化下一秒的时间

    10. let nextTimeStr = formatDate(newDate(now.getTime() + 1000), 'hhiiss')

    11. // 定义牌板数组,用来存储6个Flipper翻板对象

    12. let flipObjs = []

    13. for(let i = 0; i < flips.length; i++) {

    14.     // 创建6个Flipper实例,初始化并存入flipObjs

    15. flipObjs.push(newFlipper({

    16.         // 每个Flipper实例按数组顺序与翻板DOM的顺序一一对应

    17.     node: flips[i],

    18.         // 按数组顺序取时间字符串对应位置的数字

    19. frontText: 'number'+ nowTimeStr[i],

    20. backText: 'number'+ nextTimeStr[i]

    21.     }))

    22. }

    代码逻辑不难,请阅读注释。比较值得分享的是其中的时间格式化函数formatDate。

    知识点5:时间格式化函数的实现

    为了方便业务使用,实现一个时间格式化方法,这个方法在很多其他业务中都会使用到,具有很普遍的实用价值。

    需求是通过输入日期时间格式要求,输出对应的字符串。

    例如:

    yyyy-mm-dd hh:ii:ss 输出:2019-06-02 08:30:37

    yy-m-d h:i:s 输出:19-6-2 8:30:37

    先看代码:

    
         
         
         
         
    1. // 正则格式化日期

    2. function formatDate(date, dateFormat) {

    3.     /* 单独格式化年份,根据y的字符数量输出年份

    4. * 例如:yyyy => 2019

    5. * yy => 19

    6. * y => 9

    7. */

    8.     if(/(y+)/.test(dateFormat)) {

    9. dateFormat = dateFormat.replace(RegExp.$1, (date.getFullYear() + '').substr(4- RegExp.$1.length));

    10.     }

          // 格式化月、日、时、分、秒

          let o = {

              'm+': date.getMonth() + 1,

              'd+': date.getDate(),

              'h+': date.getHours(),

              'i+': date.getMinutes(),

              's+': date.getSeconds()

          };

          for(let k in o) {

            if(newRegExp(`(${k})`).test(dateFormat)) {

                // 取出对应的值

                let str = o[k] + '';

                /* 根据设置的格式,输出对应的字符

    11. * 例如: 早上8时,hh => 08,h => 8

    12. * 但是,当数字>=10时,无论格式为一位还是多位,不做截取,这是与年份格式化不一致的地方

    13. * 例如: 下午15时,hh => 15, h => 15

    14. */

    15. dateFormat = dateFormat.replace(RegExp.$1, (RegExp.$1.length === 1) ? str : padLeftZero(str));

    16.         }

          }

          return dateFormat;

    17. };

    18. // 日期时间补零

    19. function padLeftZero(str) {

    20.     return('00'+ str).substr(str.length);

    21. }

    代码逻辑请阅读注释,这里再补充下“日期时间补零padLeftZero”函数的说明。由于月、日、时、分、秒最多为2位数,所以这里只考虑最多补一个0的情况。

    原理是:不管数字是几位,先在前面补两个0,再根据原数字的位数进行截取,最终输出固定为两位的补零数字

    例如:数字"16"是两位数,先补两个0变成"0016",再从该字符串的索引[2]开始截取(2=原数字的位数),由于字符串索引从[0]开始,所以[2]对应字符串的第3位,输出结果仍为"16。

    同理,数字"8"是1位数,先补两个0变成"008",再从该字符串的索引[1]开始截取(1=原数字的位数),即从第2位开始截取,输出"08"。

    这样就实现了补零的功能。

    现在看下效果,已经可以正确显示当前时间了。

    如何优雅简洁地实现时钟翻牌器(支持JS/Vue/React)_第19张图片

    3.4 运行时钟

    万事俱备,只差加个定时器让时钟翻动起来。

    
         
         
         
         
    1. setInterval(function() {

    2.     // 获取当前时间

          let now = newDate()

          // 格式化当前时间

          let nowTimeStr = formatDate(newDate(now.getTime() - 1000), 'hhiiss')

          // 格式化下一秒时间

          let nextTimeStr = formatDate(now, 'hhiiss')

          // 将当前时间和下一秒时间逐位对比

          for(let i = 0; i < flipObjs.length; i++) {

              // 如果前后数字没有变化,则直接跳过,不翻牌

              if(nowTimeStr[i] === nextTimeStr[i]) {

                  continue

              }

              // 传递前后牌的数字,进行向下翻牌动画

    3. flipObjs[i].flipDown('number'+ nowTimeStr[i], 'number'+ nextTimeStr[i])

    4.     }

    5. }, 1000)

    这段代码逻辑很简单了,主要就是进行前后时间字符串的对比,然后设置纸牌并翻转。最终效果:

    如何优雅简洁地实现时钟翻牌器(支持JS/Vue/React)_第20张图片

    4 Vue & React封装

    由于篇幅有限,这里不再详述,原理都是一样的,只是利用Vue和React的API和语法进行封装。

    原生JavaScript、Vue、React三个版本的演示源码请到我的github下载:

    https://github.com/Yuezi32/flipClock

    本次分享讲解了如何优雅地实现结构简单的翻牌时钟,并对JS进行了科学高效的封装。其中也涉及到了CSS3的一些知识点和技巧。希望能对大家的工作有所帮助。

    ❤️ 看完三件事

    如果你觉得这篇内容对你挺有启发,我想邀请你帮我三个小忙:

    欢迎评论区留下你的精彩评论~

    觉得文章不错可以分享到朋友圈让更多的小伙伴看到哦~

    客官!在看一下呗

    你可能感兴趣的:(如何优雅简洁地实现时钟翻牌器(支持JS/Vue/React))