Vue.js 过渡 & 动画

admin

本章节我们主要讨论 Vue.js 的过渡效果与动画效果。

---

过渡

Vue 在插入、更新或者移除 DOM 时，提供多种不同方式的应用过渡效果。

Vue 提供了内置的过渡封装组件，该组件用于包裹要实现过渡效果的组件。

语法格式

1. <transition name = "nameoftransition">
   1 L0 }/ y9 a; W
2.    <div></div>
   , y+ q+ g1 I+ O$ x9 x, }
3. </transition>

复制代码

我们可以通过以下实例来理解 Vue 的过渡是如何实现的：

实例

  \8 ]$ [$ U3 [

1. <div id = "databinding">
   2 I/ {5 s7 c. {. b4 U$ Z7 L
2. <button v-on:click = "show = !show">点我</button>
   
3. <transition name = "fade">
   . f9 k- y6 e5 m7 \& v
4.     <p v-show = "show" v-bind:style = "styleobj">动画实例</p>
   $ m7 h9 W- F: q$ ]) b+ X
5. </transition>
   6 ^* s0 V0 c+ _. h
6. </div>
   
7. <script type = "text/javascript">
   
8. var vm = new Vue({
   
9. el: '#databinding',
   6 d1 p# U  V" ], x) P
10.     data: {
    
11.         show:true,
    
12.         styleobj :{
    
13.             fontSize:'30px',
    
14.             color:'red'
    $ m" t9 ~8 |. t) ?* Z1 `0 o6 F
15.         }
    3 f* f# v' y2 a7 h9 E
16.     },
    ; x# b5 y, g3 {6 s
17.     methods : {
    
18.     }
    / N  x- U2 ?' i& u  G) ]
19. });
    
20. </script>

复制代码

实例中通过点击 "点我" 按钮将变量 show 的值从 true 变为 false。如果为 true 显示子元素 p 标签的内容。

下面这段代码展示了 transition 标签包裹了 p 标签：

1. <transition name = "fade">
   # B: d, ^, l( A' |5 W5 O
2.     <p v-show = "show" v-bind:style = "styleobj">动画实例</p>
   " @' s" c6 u: x1 j3 q  J. I" D
3. </transition>

复制代码

过渡其实就是一个淡入淡出的效果。Vue在元素显示与隐藏的过渡中，提供了 6 个 class 来切换：

• v-enter：定义进入过渡的开始状态。在元素被插入之前生效，在元素被插入之后的下一帧移除。
• v-enter-active：定义进入过渡生效时的状态。在整个进入过渡的阶段中应用，在元素被插入之前生效，在过渡/动画完成之后移除。这个类可以被用来定义进入过渡的过程时间，延迟和曲线函数。
• v-enter-to: 2.1.8版及以上 定义进入过渡的结束状态。在元素被插入之后下一帧生效 (与此同时 v-enter 被移除)，在过渡/动画完成之后移除。
• v-leave: 定义离开过渡的开始状态。在离开过渡被触发时立刻生效，下一帧被移除。
• v-leave-active：定义离开过渡生效时的状态。在整个离开过渡的阶段中应用，在离开过渡被触发时立刻生效，在过渡/动画完成之后移除。这个类可以被用来定义离开过渡的过程时间，延迟和曲线函数。
• v-leave-to: 2.1.8版及以上 定义离开过渡的结束状态。在离开过渡被触发之后下一帧生效 (与此同时 v-leave 被删除)，在过渡/动画完成之后移除。
  
  

' X) ^* l2 ?( C  [7 D9 i

对于这些在过渡中切换的类名来说，如果你使用一个没有名字的 <transition>，则 v- 是这些类名的默认前缀。如果你使用了 <transition name="my-transition">，那么 v-enter 会替换为 my-transition-enter。

v-enter-active 和 v-leave-active 可以控制进入/离开过渡的不同的缓和曲线，在下面章节会有个示例说明。

CSS 过渡

通常我们都使用 CSS 过渡来实现效果。

如下实例：

实例
; g" D$ L) W- Q2 o
. D  V/ u' K2 o$ l: q

1. <div id = "databinding">
   5 G! X. B5 ?9 E5 u* s: y
2. <button v-on:click = "show = !show">点我</button>
   5 S" J9 K4 l. a9 ?3 a  i+ M; z# G
3. <transition name="slide-fade">
   + }( _5 P3 Z5 o( X1 Q  I
4.     <p v-if="show">hello</p>
   
5. </transition>
   
6. </div>
   5 E7 C/ @+ w  U1 ~) c% u
7. <script type = "text/javascript">
   
8. new Vue({
   2 G. L0 @7 x& l% ], V6 T
9.     el: '#databinding',
   - p/ A2 B7 I  D% y/ k% ?' B
10.     data: {
    ) y' H) r- ~5 M8 u- b
11.         show: true
    1 U, G: W5 }4 q5 Q) b0 B. ]6 d5 C$ \$ T
12.     }
    6 g! }0 \% L; ?0 Z  t: w4 ]% N
13. })
    , w* y' C. c! ^* ?
14. </script>

复制代码

- Q* b7 k* c0 O% U  V! qCSS 动画

CSS 动画用法类似 CSS 过渡，但是在动画中 v-enter 类名在节点插入 DOM 后不会立即删除，而是在 animationend 事件触发时删除。

实例
! t/ E2 y" Z' I6 B7 V5 k4 U! W. |

1. <div id = "databinding">
   
2. <button v-on:click = "show = !show">点我</button>
   
3. <transition name="bounce">
   ; L% g7 p  z8 C. T7 f9 w
4.     <p v-if="show">菜鸟教程 -- 学的不仅是技术，更是梦想！！！</p>
   / I% c5 ~% Q4 a8 t$ @5 w& U4 @
5. </transition>
   
6. </div>
   
7. <script type = "text/javascript">
   
8. new Vue({
   
9.     el: '#databinding',
   
10.     data: {
    
11.         show: true
    
12.     }
    
13. })
    
14. </script>

复制代码

自定义过渡的类名

我们可以通过以下特性来自定义过渡类名：

• enter-class
• enter-active-class
• enter-to-class (2.1.8+)
• leave-class
• leave-active-class
• leave-to-class (2.1.8+)
  " g$ t, v8 m0 k

自定义过渡的类名优先级高于普通的类名，这样就能很好的与第三方（如：animate.css）的动画库结合使用。

实例
/ A& g6 s# P, S1 ?3 M3 a1 F+ i5 @

1. <div id = "databinding">
   
2. <button v-on:click = "show = !show">点我</button>
   
3. <transition
   7 K1 c; Q- A' l! j* `& H
4.     name="custom-classes-transition"
   ) T. S% U9 _: s& E, d
5.     enter-active-class="animated tada"
   
6.     leave-active-class="animated bounceOutRight"
   
7. >
   5 g# }2 C" w3 S( k+ n3 P& |9 g/ H3 ^
8.     <p v-if="show">菜鸟教程 -- 学的不仅是技术，更是梦想！！！</p>
   1 H, e" n3 e' k; v
9. </transition>
   
10. </div>
    
11. <script type = "text/javascript">
    : P1 X) s8 x, P: t& u! L
12. new Vue({
    # o# H# x* @9 {0 ]; I3 j5 q
13.     el: '#databinding',
    
14.     data: {
    
15.         show: true
    ! j3 s5 i5 @4 x  Z* i* \* v0 i
16.     }
    
17. })
    ; A/ {. P* c0 G9 i6 j
18. </script>

复制代码

同时使用过渡和动画

Vue 为了知道过渡的完成，必须设置相应的事件监听器。它可以是 transitionend 或 animationend ，这取决于给元素应用的 CSS 规则。如果你使用其中任何一种，Vue 能自动识别类型并设置监听。

但是，在一些场景中，你需要给同一个元素同时设置两种过渡动效，比如 animation 很快的被触发并完成了，而 transition 效果还没结束。在这种情况中，你就需要使用 type 特性并设置 animation 或 transition 来明确声明你需要 Vue 监听的类型。

性的过渡持续时间

在很多情况下，Vue 可以自动得出过渡效果的完成时机。默认情况下，Vue 会等待其在过渡效果的根元素的第一个 transitionend 或 animationend 事件。然而也可以不这样设定——比如，我们可以拥有一个精心编排的一系列过渡效果，其中一些嵌套的内部元素相比于过渡效果的根元素有延迟的或更长的过渡效果。

在这种情况下你可以用 <transition> 组件上的 duration 属性定制一个显性的过渡持续时间 (以毫秒计)：

' l# z# ^/ Y# I$ o/ Q  y. }

1. <transition :duration="1000">...</transition>

复制代码

你也可以定制进入和移出的持续时间：
) f* L: o9 c( N! H% J$ R9 W( @

1. <transition :duration="{ enter: 500, leave: 800 }">...</transition>

复制代码

JavaScript 钩子

可以在属性中声明 JavaScript 钩子:

HTML 代码：
0 u! Y2 v3 D& J( E+ z

1. <transition
   
2.   v-on:before-enter="beforeEnter"
   6 q) o0 r4 i# s- D. {. h/ h9 f
3.   v-on:enter="enter"
   $ k. v' E, m8 k) S1 ?
4.   v-on:after-enter="afterEnter"
   
5.   v-on:enter-cancelled="enterCancelled"
   3 |) k) x$ d  K9 s; c
6. 
   
7.   v-on:before-leave="beforeLeave"
   6 J. W( f) o& k  Q# D
8.   v-on:leave="leave"
   
9.   v-on:after-leave="afterLeave"
   $ D% i7 E' q) l/ C2 n9 A0 ]
10.   v-on:leave-cancelled="leaveCancelled"
    
11. >
    # m0 w/ j# H8 c2 S: h
12.   <!-- ... -->
    $ M. D0 `  J4 |+ y3 z
13. </transition>

复制代码

JavaScript 代码：

1. // ...
   
2. methods: {
   
3.   // --------
   1 s# {! n1 R- `  w. O
4.   // 进入中
   
5.   // --------
   
6. 
   ( O' _( Y8 C+ W
7.   beforeEnter: function (el) {
   
8.     // ...
   $ j/ e  U4 [* S* R& H
9.   },
   & _7 R- \% a* z, }
10.   // 此回调函数是可选项的设置
    # F0 X& L& M" o; V7 D
11.   // 与 CSS 结合时使用
    ! K5 d" t& L0 X
12.   enter: function (el, done) {
    
13.     // ...
      u  Y1 p9 K8 L' i& h1 B
14.     done()
    
15.   },
    
16.   afterEnter: function (el) {
    $ B6 F4 N( s; }2 o' v. X2 Z/ e
17.     // ...
    
18.   },
    ' ?5 i0 H2 ?6 ~
19.   enterCancelled: function (el) {
    
20.     // ...
    
21.   },
    
22. 
    
23.   // --------
    
24.   // 离开时
    
25.   // --------
    ' Q& t/ X8 f6 A$ E' n& S
26. 
    
27.   beforeLeave: function (el) {
    ; J% H9 F$ P3 g; F
28.     // ...
    
29.   },
    % J/ l$ D! g0 {3 K# v) X4 R1 a
30.   // 此回调函数是可选项的设置
    
31.   // 与 CSS 结合时使用
    7 J2 o0 G' g% P' s
32.   leave: function (el, done) {
    # i" [% m0 u$ \5 |" S# ~% ?+ x
33.     // ...
    
34.     done()
    % O) ^- _7 N1 }4 f' \
35.   },
    + Z4 ?5 H- O- I
36.   afterLeave: function (el) {
    % v9 x2 f' E7 Z( H8 `4 c: T( L
37.     // ...
    2 |" g8 O. ~; n
38.   },
    
39.   // leaveCancelled 只用于 v-show 中
    
40.   leaveCancelled: function (el) {
    3 y0 N1 ?7 U4 S6 D& ~( y6 m& {. b9 v
41.     // ...
      }' k1 g* i) [" Q% t" R
42.   }
    
43. }

复制代码

这些钩子函数可以结合 CSS transitions/animations 使用，也可以单独使用。

当只用 JavaScript 过渡的时候，在 enter 和 leave 中必须使用 done 进行回调。否则，它们将被同步调用，过渡会立即完成。

推荐对于仅使用 JavaScript 过渡的元素添加 v-bind:css="false"，Vue 会跳过 CSS 的检测。这也可以避免过渡过程中 CSS 的影响。

一个使用 Velocity.js 的简单例子：

实例
6 i: r6 y8 g- R4 Z6 v! w

1. <div id = "databinding">
   
2. <button v-on:click = "show = !show">点我</button>
   
3. <transition
   
4.     v-on:before-enter="beforeEnter"
   
5.     v-on:enter="enter"
   
6.     v-on:leave="leave"
   
7.     v-bind:css="false"
   , ^! c8 n' s0 |3 C; _  R
8.   >
   
9.     <p v-if="show">菜鸟教程 -- 学的不仅是技术，更是梦想！！！</p>
   
10. </transition>
    
11. </div>
    & r" q3 p, d  ~* ^- s
12. <script type = "text/javascript">
    9 ~- O$ K/ v  u$ Z4 P# ?. g0 U
13. new Vue({
    / n: H6 s  {$ x/ e
14.   el: '#databinding',
    
15.   data: {
    + @3 B0 `& v  P% S$ y& c. T" v
16.     show: false
    
17.   },
    4 w: E) N$ T% u4 r* [+ _. W! v
18.   methods: {
    
19.     beforeEnter: function (el) {
    % ?5 }. t3 u" C& U6 C+ t
20.       el.style.opacity = 0
    
21.       el.style.transformOrigin = 'left'
    
22.     },
    
23.     enter: function (el, done) {
    
24.       Velocity(el, { opacity: 1, fontSize: '1.4em' }, { duration: 300 })
    6 w) e3 N7 j3 r0 Z7 [# C( Q
25.       Velocity(el, { fontSize: '1em' }, { complete: done })
    
26.     },
    
27.     leave: function (el, done) {
    / P" `, y0 S/ C
28.       Velocity(el, { translateX: '15px', rotateZ: '50deg' }, { duration: 600 })
    ' v# ^) r# l/ V+ _' E
29.       Velocity(el, { rotateZ: '100deg' }, { loop: 2 })
    / z6 M7 E% \; ?& L
30.       Velocity(el, {
    
31.         rotateZ: '45deg',
    + O; f# f7 l4 t9 w& _6 l; m: p" H
32.         translateY: '30px',
    
33.         translateX: '30px',
    
34.         opacity: 0
    / c% i5 u- b; i% w3 Y/ \  ]/ ^# o
35.       }, { complete: done })
    ! L+ Q: B4 h$ l' E8 w* I
36.     }
    
37.   }
    2 e( Z7 N/ i8 N6 Z7 U
38. })
    
39. </script>

复制代码

初始渲染的过渡

可以通过 appear 特性设置节点在初始渲染的过渡

: Y" k: f- P4 k) t! y6 G, ?

1. <transition appear>
   & v4 P% t1 S. U+ k" i5 \
2.   <!-- ... -->
   
3. </transition>

复制代码

这里默认和进入/离开过渡一样，同样也可以自定义 CSS 类名。

1. <transition
   
2.   appear
   
3.   appear-class="custom-appear-class"
   
4.   appear-to-class="custom-appear-to-class" (2.1.8+)
   
5.   appear-active-class="custom-appear-active-class"
   
6. >
   : W% ~4 ^5 i! ^7 L' ^
7.   <!-- ... -->
   " y9 D' x9 A1 U  M( ~
8. </transition>

复制代码

自定义 JavaScript 钩子：
( N* s3 \2 |* ?# s# g) v

1. <transition
   
2.   appear
   
3.   v-on:before-appear="customBeforeAppearHook"
   
4.   v-on:appear="customAppearHook"
   4 ~- e3 |  Y4 b. l$ K+ w
5.   v-on:after-appear="customAfterAppearHook"
   1 n/ C0 B" Q' {9 n
6.   v-on:appear-cancelled="customAppearCancelledHook"
   . V" ]/ t( t8 m8 ~% s* Z
7. >
   
8.   <!-- ... -->
   
9. </transition>

复制代码

多个元素的过渡

我们可以设置多个元素的过渡，一般列表与描述：

需要注意的是当有相同标签名的元素切换时，需要通过 key 特性设置唯一的值来标记以让 Vue 区分它们，否则 Vue 为了效率只会替换相同标签内部的内容。

1. <transition>
   
2.   <table v-if="items.length > 0">
   4 y9 g3 z. E* v* J
3.     <!-- ... -->
   
4.   </table>
   
5.   <p v-else>抱歉，没有找到您查找的内容。</p>
   
6. </transition>

复制代码

如下实例：
9 L) L& \1 t8 H7 e8 L

1. <transition>
   6 X* J5 y+ j" {/ `  `8 l
2.   <button v-if="isEditing" key="save">
   ; j8 `1 y4 P0 Q3 h
3.     Save
   / \2 K, O) S* ^% b1 p
4.   </button>
   ; N  _! U% [" w* g3 d
5.   <button v-else key="edit">
   + v" V1 L. L9 F$ j* w2 m4 ?
6.     Edit
   
7.   </button>
   
8. </transition>

复制代码

在一些场景中，也可以通过给同一个元素的 key 特性设置不同的状态来代替 v-if 和 v-else，上面的例子可以重写为：
2 @2 W! f& `2 J- ?4 O- c0 w/ `

1. <transition>
   2 n% n- U' s" [) Q
2.   <button v-bind:key="isEditing">
   ( t' o) r1 N: A1 V7 ?; L' l! \
3.     {{ isEditing ? 'Save' : 'Edit' }}
   8 Q& c3 o" H) \
4.   </button>
   ! O2 P* B7 {, a2 G
5. </transition>

复制代码

使用多个 v-if 的多个元素的过渡可以重写为绑定了动态属性的单个元素过渡。例如：

1. <transition>
   8 i7 E! P) H0 c+ g0 }
2.   <button v-if="docState === 'saved'" key="saved">
   
3.     Edit
   + t, p3 [9 q# `5 k9 g; g
4.   </button>
   - O& r8 Z$ p  M" u4 \
5.   <button v-if="docState === 'edited'" key="edited">
   
6.     Save
   
7.   </button>
   9 p3 D; q! u8 p6 s4 y3 u
8.   <button v-if="docState === 'editing'" key="editing">
   / o9 e# @2 N, O
9.     Cancel
   
10.   </button>
    
11. </transition>

复制代码

可以重写为：

1. <transition>
   ! {, s8 |1 L. e# E* m' k. W
2.   <button v-bind:key="docState">
   
3.     {{ buttonMessage }}
   
4.   </button>
   % G3 M, R7 P4 V) V. w7 a1 Z$ o' A
5. </transition>
   
6. 
   
7. // ...
   
8. computed: {
   * G% x( k$ B% u/ D2 b1 U/ [
9.   buttonMessage: function () {
   7 e0 c3 S1 L! T0 J# R/ x6 w0 S. u
10.     switch (this.docState) {
    
11.       case 'saved': return 'Edit'
    0 o8 d$ j: g# e- @! O* q- J8 d
12.       case 'edited': return 'Save'
    
13.       case 'editing': return 'Cancel'
    
14.     }
    + d0 d- |: u# d1 P- H4 m/ y5 k
15.   }
    / h% n0 [  s* i* l0 ~
16. }

复制代码

完
& |9 ^% w1 u* l+ G

  @( n& {8 f% @0 K/ _